Merge branch 'master' of http://darcs.haskell.org/testsuite
[ghc.git] / testsuite / tests / perf / compiler / all.T
1 def no_lint(opts):
2    opts.compiler_always_flags = \
3        filter(lambda opt: opt != '-dcore-lint' and opt != '-dcmm-lint', opts.compiler_always_flags)
4
5 setTestOpts(no_lint)
6
7
8 test('T1969',
9      [if_wordsize(32,
10           compiler_stats_num_field('peak_megabytes_allocated', 13,
11                                                                19)),
12                              # expected value: 14 (x86/Windows 17/05/10)
13                              #                 15 (x86/OS X)
14                              #                 19 (x86/OS X)
15       if_wordsize(64,
16           compiler_stats_num_field('peak_megabytes_allocated', 22,
17                                                                28)),
18                                              # expected value: 28 (amd64/Linux)
19                                              # expected value: 34 (amd64/Linux)
20                                              # 2012-09-20      23 (amd64/Linux)
21                                              # 2012-10-03      25 (amd64/Linux if .hi exists)
22       if_wordsize(32,
23           compiler_stats_num_field('max_bytes_used', 4000000,
24                                                      7000000)),
25                              # expected value: 6707308 (x86/OS X)
26                              #                 5717704 (x86/Windows 17/05/10)
27                              #                 6149572 (x86/Linux, 31/12/09)
28       if_wordsize(64,
29           compiler_stats_range_field('max_bytes_used', 9000000, 15)),
30                                   # looks like the peak is around 10M, but we're
31                                   # unlikely to GC exactly on the peak.
32                                   # varies quite a lot with CLEANUP and BINDIST,
33                                   # hence 10% range.
34       if_wordsize(32,
35           compiler_stats_num_field('bytes allocated', 210000000,
36                                                       290000000)),
37                                     # expected value: 215582916 (x86/Windows)
38                                     #                 221667908 (x86/OS X)
39                                     #                 274932264 (x86/Linux)
40       if_wordsize(64,
41           compiler_stats_range_field('bytes allocated', 641959976, 1)),
42                                     # 17/11/2009:     434,845,560 (amd64/Linux)
43                                     # 08/12/2009:     459,776,680 (amd64/Linux)
44                                     # 17/05/2010:     519,377,728 (amd64/Linux)
45                                     # 05/08/2011:     561,382,568 (amd64/OS X)
46                                     # 16/07/2012:     589,168,872 (amd64/Linux)
47                                     # 20/07/2012:     595,936,240 (amd64/Linux)
48                                     # 23/08/2012:     606,230,880 (amd64/Linux)
49                                     # 29/08/2012:     633,334,184 (amd64/Linux)
50                                     #                 (^ new codegen)
51                                     # 18/09/2012:     641,959,976 (amd64/Linux)
52       only_ways(['normal']),
53       extra_hc_opts('-dcore-lint -static')
54           # Leave -dcore-lint on for this one test, so that we have something
55           # that will catch a regression in -dcore-lint performance.
56       ],
57      compile,
58      [''])
59
60 # This one tests for the space leak in the native code generator,
61 # where it holds onto the entire asm output until the end.  The space
62 # leak reappears from time to time, so it's a good idea to have a test
63 # for it.  The residency of this test will jump by 10MB to 40MB or so
64 # on x86-64 if the space leak appears.
65
66 # Only run this one if we have an NCG:
67 if 'optasm' in config.compile_ways:
68    conf_3294 = only_ways(['normal'])
69 else:
70    conf_3294 = skip
71
72 test('T3294',
73      [if_wordsize(32,
74           compiler_stats_num_field('max_bytes_used', 12000000,
75                                                      20000000)),
76                                    # expected value: 17725476 (x86/OS X)
77                                    #                 14593500 (Windows)
78       if_wordsize(64,
79           compiler_stats_range_field('max_bytes_used', 37724352, 15)),
80                                    # prev:           25753192 (amd64/Linux)
81                                    # 29/08/2012:     37724352 (amd64/Linux)
82                                    #  (increase due to new codegen, see #7198)
83       if_wordsize(32,
84           compiler_stats_num_field('bytes allocated', 650000000,
85                                                       750000000)),
86                                     # expected value: 815479800  (x86/Linux)
87       if_wordsize(64,
88           compiler_stats_range_field('bytes allocated', 2717327208, 5)),
89                                    # old:        1,357,587,088 (amd64/Linux)
90                                    # 29/08/2012: 2,961,778,696 (amd64/Linux)
91                                    # (^ increase due to new codegen, see #7198)
92                                    # 18/09/2012: 2,717,327,208 (amd64/Linux)
93       conf_3294
94       ],
95      compile,
96      [''])
97
98 test('T4801',
99      [ # expect_broken(5224),
100        # temporarily unbroken (#5227)
101       if_wordsize(32,
102           compiler_stats_range_field('peak_megabytes_allocated', 30, 20)),
103       if_wordsize(64, # sample from (amd64/Linux):
104           compiler_stats_range_field('peak_megabytes_allocated', 50, 20)),
105       # expected value: 58 (amd64/OS X):
106       if_platform('x86_64-apple-darwin',
107           compiler_stats_num_field('peak_megabytes_allocated', 56, 60)),
108       # expected value: 228286660 (x86/OS X)
109       if_wordsize(32,
110           compiler_stats_range_field('bytes allocated', 185669232, 10)),
111       if_wordsize(64, # (amd64/Linux):
112           compiler_stats_range_field('bytes allocated', 360243576, 10)),
113       # expected value: 510938976 (amd64/OS X):
114       if_platform('x86_64-apple-darwin',
115           compiler_stats_num_field('bytes allocated', 490000000,
116                                                       530000000)),
117       if_wordsize(32,
118       #                    expected value: x86/OS X:  9651948
119           compiler_stats_num_field('max_bytes_used',  8000000,
120                                                      12000000)),
121       # expected value: 10290952 (windows)
122       if_wordsize(64,
123           compiler_stats_range_field('max_bytes_used', 18500000, 15)),
124                 # prev:       20486256 (amd64/OS X)
125                 # 30/08/2012: 17305600--20391920 (varies a lot)
126       if_platform('x86_64-apple-darwin',
127           compiler_stats_num_field('max_bytes_used', 20000000,
128                                                      23000000)),
129        only_ways(['normal']),
130        extra_hc_opts('-static')
131       ],
132      compile,
133      [''])
134
135 test('T3064',
136      [# expect_broken( 3064 ),
137       # expected value: 14 (x86/Linux 28-06-2012):
138       if_wordsize(32,
139           compiler_stats_range_field('peak_megabytes_allocated', 14, 30)),
140       # expected value: 18 (amd64/Linux):
141       if_wordsize(64,
142           compiler_stats_num_field('peak_megabytes_allocated', 20, 28)),
143       # expected value: 56380288 (x86/Linux) (28/6/2011)
144       if_wordsize(32,
145           compiler_stats_range_field('bytes allocated', 124952112, 10)),
146       # expected value: 73259544 (amd64/Linux) (28/6/2011):
147       if_wordsize(64,
148           compiler_stats_num_field('bytes allocated', 200000000,
149                                                       280000000)),
150       # expected value: 2247016 (x86/Linux) (28/6/2011):
151       if_wordsize(32,
152           compiler_stats_range_field('max_bytes_used', 5511604, 20)),
153       # expected value: 4032024 (amd64/Linux, intree) (28/6/2011):
154       if_wordsize(64,
155           compiler_stats_num_field('max_bytes_used', 8000000,
156                                                      14000000)),
157        only_ways(['normal'])
158       ],
159      compile,
160      [''])
161
162 test('T4007',
163      normal,
164      run_command,
165      ['$MAKE -s --no-print-directory T4007'])
166
167 test('T5030',
168      [# expected value: 449368924 (x86/Linux)
169       if_wordsize(32,
170           compiler_stats_range_field('bytes allocated', 196457520, 10)),
171       # expected value: 346750856 (amd64/Linux):
172       if_wordsize(64,
173           compiler_stats_range_field('bytes allocated', 530000000, 10)),
174        only_ways(['normal'])
175       ],
176      compile,
177      ['-fcontext-stack=300'])
178
179 test('T5631',
180      [if_wordsize(32, # sample from x86/Linux
181           compiler_stats_range_field('bytes allocated', 392904228, 10)),
182       # expected value: 774,595,008 (amd64/Linux):
183       if_wordsize(64,
184           compiler_stats_num_field('bytes allocated', 600000000,
185                                                       900000000)),
186        only_ways(['normal'])
187       ],
188      compile,
189      [''])
190
191 test('parsing001',
192      [# expected value: ?
193       if_wordsize(32,
194           compiler_stats_range_field('bytes allocated', 274000576, 10)),
195       # expected value: 587079016 (amd64/Linux):
196       if_wordsize(64,
197           compiler_stats_num_field('bytes allocated', 540000000,
198                                                       620000000)),
199        only_ways(['normal']),
200       ],
201      compile_fail, [''])
202
203
204 test('T783',
205      [ only_ways(['normal']),  # no optimisation for this one
206       # expected value: 175,569,928 (x86/Linux)
207       if_wordsize(32,
208           compiler_stats_num_field('bytes allocated', 125000000,
209                                                       225000000)),
210       if_wordsize(64,
211           compiler_stats_range_field('bytes allocated', 436927840, 10)),
212                            # prev:       349,263,216 (amd64/Linux)
213                            # 07/08/2012: 384,479,856 (amd64/Linux)
214                            # 29/08/2012: 436,927,840 (amd64/Linux)
215       extra_hc_opts('-static')
216       ],
217       compile,[''])
218
219 test('T5321Fun',
220      [ only_ways(['normal']),  # no optimisation for this one
221       # sample from x86/Linux
222       if_wordsize(32,
223           compiler_stats_range_field('bytes allocated', 300000000, 10)),
224       if_wordsize(64,
225           compiler_stats_range_field('bytes allocated', 713385808, 10))
226                                          # prev:       585,521,080
227                                          # 29/08/2012: 713,385,808
228                                          #  (increase due to new codegen)
229       ],
230       compile,[''])
231
232 test('T5321FD',
233      [ only_ways(['normal']),  # no optimisation for this one
234       # sample from x86/Linux
235       if_wordsize(32,
236           compiler_stats_range_field('bytes allocated', 213380256, 10)),
237       if_wordsize(64,
238           compiler_stats_range_field('bytes allocated', 492905640, 10))
239                                          # prev:       418,306,336
240                                          # 29/08/2012: 492,905,640
241                                          #  (increase due to new codegen)
242       ],
243       compile,[''])
244
245 test('T5642',
246      [ only_ways(['normal']),
247       if_wordsize(32, # sample from x86/Linux
248           compiler_stats_range_field('bytes allocated',  650000000, 10)),
249       if_wordsize(64,
250           compiler_stats_range_field('bytes allocated', 1300000000, 10))
251       ],
252       compile,['-O'])
253
254 test('T5837',
255      [ only_ways(['normal']),
256       if_wordsize(32, # sample from x86/Linux
257           compiler_stats_range_field('bytes allocated', 40000000, 10)),
258
259       # sample: 3926235424 (amd64/Linux, 15/2/2012)
260       if_wordsize(64,
261           compiler_stats_range_field('bytes allocated', 81879216, 10))
262                                            # 2012-10-02 81879216
263                                            # 2012-09-20 87254264 amd64/Linux
264       ],
265       compile_fail,['-fcontext-stack=50'])
266
267 test('T6048',
268      [ only_ways(['optasm']),
269       if_wordsize(32, # sample from x86/Linux
270           compiler_stats_range_field('bytes allocated', 38000000, 10)),
271
272       if_wordsize(64,
273           compiler_stats_range_field('bytes allocated', 97247032, 10))
274                                            # 18/09/2012 97247032 amd64/Linux
275       ],
276       compile,[''])