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