Use `+RTS -G1` for more stable residency measurements (#9675)
[ghc.git] / testsuite / tests / perf / should_run / all.T
1 # Tests that newArray/newArray_ is being optimised correctly
2
3 test('T10359',
4      [stats_num_field('bytes allocated',
5           [(wordsize(64), 499512, 5),
6            (wordsize(32), 374056, 5)]),
7       only_ways(['normal'])
8       ],
9      compile_and_run,
10      ['-O'])
11
12 # fortunately the values here are mostly independent of the wordsize,
13 # because the test allocates an unboxed array of doubles.
14 test('T3586',
15      [stats_num_field('peak_megabytes_allocated', (17, 1)),
16                                  # expected value: 17 (amd64/Linux)
17       stats_num_field('bytes allocated', (16102024, 5)),
18                         # prev:           16835544 (amd64/Linux)
19                         # 2014-07-17:     16102024 (amd64/Linux), general round of updates
20       only_ways(['normal']),
21
22       # Use `+RTS -G1` for more stable residency measurements. Note [residency].
23       # Only 64-bit as we don't have a good 32-bit test environment at the moment
24       when(wordsize(64), extra_hc_opts('+RTS -G1 -RTS'))
25       ],
26      compile_and_run,
27      ['-O'])
28
29 test('T4830',
30      [stats_num_field('bytes allocated',
31           [(wordsize(64), 98248, 4),
32            #             127000 (amd64/Linux)
33            # 2013-02-07:  99264 (amd64/Linux)
34            # 2014-01-13:  98248 (amd64/Linux) due to #8647
35            # 2015-04-03: Widen 1->4% (amd64/Windows was doing better)
36            (wordsize(32), 70646, 3)]),
37            # 2013-02-10:  69744 (x86/Windows)
38            # 2013-02-10:  71548 (x86/OSX)
39            # 2014-01-28:  Widen range 2->3
40            #                (x86/Windows - actual 69000, lower was 69233)
41       only_ways(['normal'])
42       ],
43      compile_and_run,
44      ['-O2'])
45
46 test('T3245', [when(doing_ghci(), extra_hc_opts('-fobject-code'))],
47      compile_and_run, ['-O'])
48
49 # Test that bytestring reading/writing isn't over-allocating.  We had
50 # a bug in hGetBufNonBlocking in 6.13 that triggered this.
51 #
52 test('lazy-bs-alloc',
53      [stats_num_field('peak_megabytes_allocated', (2, 1)),
54                                  # expected value: 2 (amd64/Linux)
55       stats_num_field('bytes allocated',
56           [(wordsize(64), 425400, 3),
57             #             489776 (amd64/Linux)
58             # 2013-02-07: 429744 (amd64/Linux)
59             # 2013-12-12: 425400 (amd64/Linux)
60             # 2015-04-04: Widen 1->3% (amd64/Windows was failing)
61            (wordsize(32), 411500, 2)]),
62             # 2013-02-10: 421296 (x86/Windows)
63             # 2013-02-10: 414180 (x86/OSX)
64             # 2014-01-22: 411500 (x86/Linux)
65             # 2014-01-28: Widen 1->2% (x86/Windows was at 425212)
66       only_ways(['normal']),
67       extra_run_opts('../../numeric/should_run/arith011.stdout'),
68       ignore_output,
69
70       # Use `+RTS -G1` for more stable residency measurements. Note [residency].
71       # Only 64-bit as we don't have a good 32-bit test environment at the moment
72       when(wordsize(64), extra_hc_opts('+RTS -G1 -RTS'))
73       ],
74      # use a suitably big file, without bloating the repo with a new one:
75      compile_and_run,
76      ['-O'])
77
78 test('T876',
79      [stats_num_field('bytes allocated',
80           [(platform('x86_64-unknown-mingw32'), 71904, 5),
81               # 2015-04-03: 71904 (amd64/Windows, unknown cause)
82            (wordsize(64), 63216 , 5),
83               # 2013-02-14: 1263712 (x86_64/Linux)
84               # 2014-02-10:   63216 (x86_64/Linux), call arity analysis
85
86            (wordsize(32), 56796, 5) ]),
87               # some date:  663712  (Windows, 64-bit machine)
88               # 2014-04-04:  56820  (Windows, 64-bit machine)
89               # 2014-06-29:  53024  (x86_64/Linux)
90               # 2014-12-01:  56796  (Windows)
91
92       only_ways(['normal']),
93       extra_run_opts('10000')
94       ],
95      compile_and_run,
96      ['-O'])
97
98 # Get reproducible floating-point results on x86
99 if config.arch == 'i386':
100    sse2_opts = '-msse2'
101 else:
102    sse2_opts = ''
103
104 test('T4321',
105      omit_ways(['ghci']),
106      compile_and_run, ['-O ' + sse2_opts])
107
108 test('T3736',
109      extra_clean(['T3736.speed.f32']),
110      run_command,
111      ['$MAKE -s --no-print-directory T3736'])
112 test('T3738',
113      [extra_clean(['T3738a.hi', 'T3738a.o']),
114       stats_num_field('peak_megabytes_allocated', (1, 0)),
115                                  # expected value: 1 (amd64/Linux)
116       stats_num_field('bytes allocated',
117                       [(wordsize(32), 45648, 5),
118                     # expected value: 50520 (x86/Linux)
119                        (wordsize(64), 50592, 8)]),
120                     # prev:           49400 (amd64/Linux)
121                     # 2014-07-17:     50520 (amd64/Linux) general round of updates
122                     # 2014-09-10:     50592 (amd64/Linux) post-AMP-update
123                     # 2015-04-03: Widen 5->8% (amd64/Windows was doing better)
124       only_ways(['normal'])
125       ],
126      compile_and_run,
127      ['-O'])
128
129 test('MethSharing',
130      [stats_num_field('peak_megabytes_allocated', (1, 0)),
131                                  # expected value: 1 (amd64/Linux)
132       stats_num_field('bytes allocated',
133                       [(wordsize(32), 360940756, 5),
134                     # expected value: 2685858140 (x86/OS X)
135                           # expected: 360940756 (x86/Linux)
136                        (wordsize(64), 640067672, 5)]),
137                           # expected: 640067672 (amd64/Linux)
138       only_ways(['normal'])
139       ],
140      compile_and_run,
141      ['-O'])
142 test('T2902',
143      extra_clean(['T2902_A',    'T2902_B',
144                   'T2902_A.hi', 'T2902_B.hi',
145                   'T2902_A.o',  'T2902_B.o',
146                   'T2902_A_PairingSum.hi', 'T2902_B_PairingSum.hi',
147                   'T2902_A_PairingSum.o',  'T2902_B_PairingSum.o',
148                   'T2902_Sum.hi',
149                   'T2902_Sum.o']),
150      run_command,
151      ['$MAKE -s --no-print-directory T2902'])
152 test('T149',
153      [ # expect_broken(149),
154        # working (2 Jul 2013, x86-64/Linux)
155       extra_clean(['T149_A',    'T149_B',
156                    'T149_A.hi', 'T149_B.hi',
157                    'T149_A.o',  'T149_B.o'])],
158      run_command,
159      ['$MAKE -s --no-print-directory T149'])
160
161 test('T5113',
162      [stats_num_field('bytes allocated',
163                       [(wordsize(32), 4000000, 5),
164                        (wordsize(64), 8000000, 5)]),
165       only_ways(['normal'])
166       ],
167      compile_and_run,
168      ['-O'])
169
170
171 test('T4978',
172      [stats_num_field('bytes allocated',
173                       [(wordsize(32), 10000000, 5),
174                        (wordsize(64), 10137680, 5)]),
175                     # expected value: 10137680 (amd64/Linux)
176       only_ways(['normal'])
177       ],
178      compile_and_run,
179      ['-O2'])
180
181 test('T5205',
182      [stats_num_field('bytes allocated',
183                       [(wordsize(32), 47088, 5),
184                     # expected value: 47088 (x86/Darwin)
185                        (wordsize(64), 52600, 7)]),
186                     # expected value: 51320 (amd64/Linux)
187                     # 2014-07-17:     52600 (amd64/Linux) general round of updates
188                     # 2015-04-03: Widen 5->7% (amd64/Windows was doing better)
189       only_ways(['normal', 'optasm'])
190       ],
191      compile_and_run,
192      [''])
193
194 test('T5549',
195      [stats_num_field('bytes allocated',
196                       [(wordsize(32), 4096606332, 5),
197                     # expected value: 3362958676 (Windows)
198                     # 2014-12-01:     4096606332 (Windows) integer-gmp2
199
200                        (wordsize(64), 8193140752, 5)]),
201                     # expected value: 6725846120 (amd64/Linux)
202                     #                 8193140752 (amd64/Linux) integer-gmp2
203       only_ways(['normal'])
204       ],
205      compile_and_run,
206      ['-O'])
207
208 test('T4474a',
209      [stats_num_field('bytes allocated',
210                       [(wordsize(32), 2405242767, 5),
211                        (wordsize(64), 4831890304, 5)]),
212                     # expected value: 4831890304 (amd64/OSX)
213       only_ways(['normal'])
214       ],
215      compile_and_run,
216      ['-O'])
217 test('T4474b',
218      [stats_num_field('bytes allocated',
219                       [(wordsize(32), 2405242767, 5),
220                        (wordsize(64), 4831890304, 5)]),
221                     # expected value: 4831890304 (amd64/OSX)
222       only_ways(['normal'])
223       ],
224      compile_and_run,
225      ['-O'])
226 test('T4474c',
227      [stats_num_field('bytes allocated',
228                       [(wordsize(32), 2405242767, 5),
229                        (wordsize(64), 4831890304, 5)]),
230                     # expected value: 4831890304 (amd64/OSX)
231       only_ways(['normal'])
232       ],
233      compile_and_run,
234      ['-O'])
235
236 test('T5237',
237      [stats_num_field('bytes allocated',
238                         [(platform('i386-unknown-mingw32'), 73280, 5),
239                          (wordsize(32), 78328, 5),
240                       # expected value: 78328 (i386/Linux)
241                          (wordsize(64), 104176, 5)]),
242                       # expected value: 110888 (amd64/Linux)
243                       # expected value: 104176 (amd64/Linux)
244      only_ways(['normal'])
245      ],
246     compile_and_run,
247     ['-O ' + sse2_opts])
248
249 test('T5536',
250      [stats_num_field('bytes allocated',
251                       [(wordsize(32), 446260520, 1),
252                                    # 1246287228 (i386/Linux)
253                                     # 446328556 (i386/Windows)
254                                     # 446192484 (i386/OSX)
255                        (wordsize(64), 892399040, 5)]),
256                    # expected value: 2492589480 (amd64/Linux)
257                    # 17/1/13:         892399040 (x86_64/Linux)
258                    #                  (new demand analyser)
259      extra_clean(['T5536.data']),
260      ignore_output,
261      only_ways(['normal'])
262      ],
263     compile_and_run,
264     ['-O'])
265
266 test('T7257',
267      [stats_num_field('bytes allocated',
268                       [(wordsize(32), 1150000000, 10),
269                     # expected value: 1246287228 (i386/Linux)
270                        (wordsize(64), 1774893760, 5)]),
271                         # 2012-09-21: 1774893760 (amd64/Linux)
272       stats_num_field('peak_megabytes_allocated',
273                       [(wordsize(32), 217, 5),
274                         # 2012-10-08: 217 (x86/Linux)
275                        (wordsize(64), 227, 5)]),
276                         # 2012-09-21: 227 (amd64/Linux)
277
278       only_ways(['normal'])
279      ],
280     compile_and_run, ['-O'])
281
282 test('Conversions',
283      [stats_num_field('bytes allocated',
284                       [(wordsize(32), 76768, 3),
285                         # 2012-12-18: 55316 Guessed 64-bit value / 2
286                         # 2013-02-10: 77472 (x86/OSX)
287                         # 2013-02-10: 79276 (x86/Windows)
288                         # 2014-01-13: 76768 (x86/Linux) due to #8647
289                        (wordsize(64), 107544, 5)]),
290                         # 2012-12-18: 109608 (amd64/OS X)
291                         # 2014-07-17: 107544 (amd64/Linux)
292
293       only_ways(['normal'])
294      ],
295     compile_and_run, ['-O -msse2'])
296
297 test('T7507', omit_ways(['ghci']), compile_and_run, ['-O'])
298 # For 7507, stack overflow is the bad case
299
300 test('T7436',
301      [stats_num_field('max_bytes_used',
302           [(wordsize(64), 60360, 4),
303            #             127000 (amd64/Linux)
304            # 2013-02-07:  60360 (amd64/Linux)
305            # 2015-04-03: Widen 1->4% (amd64/Windows was doing better)
306            (wordsize(32), 58434, 1)]),
307             # 2013-02-10: 58032 (x86/Windows)
308             # 2013-02-10: 58836 (x86/OSX)
309       only_ways(['normal'])
310       ],
311      compile_and_run,
312      ['-O'])
313
314 test('T7797',
315       [stats_num_field('bytes allocated',
316                       [(wordsize(32), 240044984, 5),
317                           # expected value: 2685858140 (x86/OS X)
318                           # expected: 360940756 (x86/Linux)
319                           # expected: 240044984 (x86/Windows, 64bit machine)
320                        (wordsize(64), 480050944, 5)]),
321                           # expected: 480050944 (amd64/Linux)
322       extra_clean(['T7797a.hi', 'T7797a.o']),
323       only_ways(['normal'])
324       ],
325      compile_and_run,
326      ['-O'])
327
328 test('T7954',
329       [stats_num_field('bytes allocated',
330                       [(wordsize(32), 920045264, 10),
331               # some date:  1380051408    (64-bit Windows machine)
332               # 2014-04-04:  920045264    (64-bit Windows machine)
333                        (wordsize(64), 1680051336, 10)]),
334               # 2014-02-10: 1680051336 (x86_64/Linux), call arity analysis
335       only_ways(['normal'])
336       ],
337      compile_and_run,
338      ['-O'])
339
340 test('T7850',
341      [stats_num_field('peak_megabytes_allocated', 
342                       [(wordsize(32), 2, 10),
343                        (wordsize(64), 4, 10)]),
344       only_ways(['normal'])],
345      compile_and_run,
346      ['-O'])
347
348 test('T5949',
349      [stats_num_field('bytes allocated',
350                       [ (wordsize(32), 116020, 10),
351                         (wordsize(64), 201008, 10)]),
352                       # previously, it was >400000 bytes
353       only_ways(['normal'])],
354      compile_and_run,
355      ['-O'])
356
357 test('T4267',
358      [stats_num_field('bytes allocated',
359                       [ (wordsize(32), 36012, 10)
360                       # 32-bit value close to 64 bit; c.f. T7619
361                       , (wordsize(64), 40992, 10) ]),
362                       # previously, it was >170000 bytes
363                       # 2014-01-17: 130000
364                       # 2014-02-10: 40992 (x86_64/Linux), call arity analysis
365       only_ways(['normal'])],
366      compile_and_run,
367      ['-O'])
368
369 test('T7619',
370      [stats_num_field('bytes allocated',
371                       [ (wordsize(32), 36012, 10)
372                       # 32-bit close to 64-bit value; most of this very 
373                       # small number is standard start-up boilerplate I think
374                       , (wordsize(64), 40992, 10) ]),
375                       # previously, it was >400000 bytes
376       only_ways(['normal'])],
377      compile_and_run,
378      ['-O'])
379
380 test('InlineArrayAlloc',
381      [stats_num_field('bytes allocated',
382                       [ (wordsize(32), 800040960, 5)
383                       , (wordsize(64), 1600040960, 5) ]),
384       only_ways(['normal'])],
385      compile_and_run,
386      ['-O2'])
387
388 test('InlineByteArrayAlloc',
389      [stats_num_field('bytes allocated',
390                       [ (wordsize(32), 1360036012, 5)
391                       , (wordsize(64), 1440040960, 5) ]),
392          # 32 and 64 bit not so different, because 
393          # we are allocating *byte* arrays
394       only_ways(['normal'])],
395      compile_and_run,
396      ['-O2'])
397
398 test('InlineCloneArrayAlloc',
399      [stats_num_field('bytes allocated',
400                       [ (wordsize(32), 800041120, 5) 
401                       , (wordsize(64), 1600041120, 5) ]),
402       only_ways(['normal'])],
403      compile_and_run,
404      ['-O2'])
405
406 test('T9203',
407      [stats_num_field('bytes allocated',
408                       [ (wordsize(32), 50000000, 5)
409                       , (wordsize(64), 94547280, 5) ]),
410                       # was            95747304
411                       # 2019-09-10     94547280 post-AMP cleanup
412       only_ways(['normal'])],
413      compile_and_run,
414      ['-O2'])
415
416 test('T9339',
417      [stats_num_field('bytes allocated',
418                       [ (wordsize(32),    40046844, 5)
419                       , (wordsize(64),    80050760, 5) ]),
420                       # w/o fusing last: 320005080
421                       # 2014-07-22:       80050760
422       only_ways(['normal'])],
423      compile_and_run,
424      ['-O2'])