84adb58dffd81e8959a439cc462d5e3f68371c17
[ghc.git] / testsuite / tests / perf / compiler / all.T
1 def no_core_lint(opts):
2    opts.compiler_always_flags = \
3        filter(lambda opt: opt != '-dcore-lint', opts.compiler_always_flags)
4
5 setTestOpts(no_core_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', 24,
17                                                                37)),
18                                              # expected value: 28 (amd64/Linux)
19                                              # expected value: 34 (amd64/Linux)
20       if_wordsize(32,
21           compiler_stats_num_field('max_bytes_used', 5000000,
22                                                      7000000)),
23                              # expected value: 6707308 (x86/OS X)
24                              #                 5717704 (x86/Windows 17/05/10)
25                              #                 6149572 (x86/Linux, 31/12/09)
26       if_wordsize(64,
27           compiler_stats_range_field('max_bytes_used', 11000000, 15)),
28                                   # expected value: 11178376 (amd64/Linux)
29                                   # varies quite a lot with CLEANUP and BINDIST,
30                                   # hence 15% range.
31       if_wordsize(32,
32           compiler_stats_num_field('bytes allocated', 210000000,
33                                                       270000000)),
34                                     # expected value: 215582916 (x86/Windows)
35                                     #                 221667908 (x86/OS X)
36       if_wordsize(64,
37           compiler_stats_num_field('bytes allocated', 420000000,
38                                                       580000000)),
39                                     # 17/11/2009:     434,845,560 (amd64/Linux)
40                                     # 08/12/2009:     459,776,680 (amd64/Linux)
41                                     # 17/05/2010:     519,377,728 (amd64/Linux)
42                                     # 05/08/2011:     561,382,568 (amd64/OS X)
43       only_ways(['normal']),
44       extra_hc_opts('-dcore-lint')
45           # Leave -dcore-lint on for this one test, so that we have something
46           # that will catch a regression in -dcore-lint performance.
47       ],
48      compile,
49      [''])
50
51 # This one tests for the space leak in the native code generator,
52 # where it holds onto the entire asm output until the end.  The space
53 # leak reappears from time to time, so it's a good idea to have a test
54 # for it.  The residency of this test will jump by 10MB to 40MB or so
55 # on x86-64 if the space leak appears.
56
57 # Only run this one if we have an NCG:
58 if 'optasm' in config.compile_ways:
59    conf_3294 = only_ways(['normal'])
60 else:
61    conf_3294 = skip
62
63 test('T3294',
64      [if_wordsize(32,
65           compiler_stats_num_field('max_bytes_used', 14000000,
66                                                      20000000)),
67                                    # expected value: 17725476 (x86/OS X)
68                                    #                 14593500 (Windows)
69       if_wordsize(64,
70           compiler_stats_num_field('max_bytes_used', 26000000,
71                                                      37000000)),
72                                    # expected value: 32 478 408 (amd64/Linux)
73                                    # (but varies a lot, depending on when
74                                    # we GC relative to the peak).
75                                    # (MCB: consistently reaching ~35 375 912 for
76                                    # me lately on amd64/Darwin)
77       if_wordsize(32,
78           compiler_stats_num_field('bytes allocated', 650000000,
79                                                       750000000)),
80                                     # expected value: 815479800  (x86/Linux)
81       if_wordsize(64,
82           compiler_stats_num_field('bytes allocated', 1200000000,
83                                                       1500000000)),
84                                     # expected value: 1357587088 (amd64/Linux)
85       conf_3294
86       ],
87      compile,
88      [''])
89
90 test('T4801',
91      [ # expect_broken(5224),
92        # temporarily unbroken (#5227)
93       if_wordsize(32,
94           compiler_stats_range_field('peak_megabytes_allocated', 30, 10)),
95       if_wordsize(64, # sample from (amd64/Linux):
96           compiler_stats_range_field('peak_megabytes_allocated', 50, 20)),
97       # expected value: 58 (amd64/OS X):
98       if_platform('x86_64-apple-darwin',
99           compiler_stats_num_field('peak_megabytes_allocated', 56, 60)),
100       # expected value: 228286660 (x86/OS X)
101       if_wordsize(32,
102           compiler_stats_range_field('bytes allocated', 185669232, 10)),
103       if_wordsize(64, # (amd64/Linux):
104           compiler_stats_range_field('bytes allocated', 360243576, 10)),
105       # expected value: 510938976 (amd64/OS X):
106       if_platform('x86_64-apple-darwin',
107           compiler_stats_num_field('bytes allocated', 490000000,
108                                                       530000000)),
109       if_wordsize(32,
110       #                    expected value: x86/OS X:  9651948
111           compiler_stats_num_field('max_bytes_used',  9000000,
112                                                      12000000)),
113       # expected value: 18188272 (amd64/Linux)
114       #                 10290952 (windows)
115       if_wordsize(64,
116           compiler_stats_num_field('max_bytes_used', 15000000,
117                                                      20000000)),
118       # expected value: 20486256 (amd64/OS X):
119       if_platform('x86_64-apple-darwin',
120           compiler_stats_num_field('max_bytes_used', 20000000,
121                                                      23000000)),
122        only_ways(['normal'])
123       ],
124      compile,
125      [''])
126
127 test('T3064',
128      [# expect_broken( 3064 ),
129       # expected value: 9 (x86/Linux 30-03-2011):
130       if_wordsize(32,
131           compiler_stats_range_field('peak_megabytes_allocated', 14, 15)),
132       # expected value: 18 (amd64/Linux):
133       if_wordsize(64,
134           compiler_stats_num_field('peak_megabytes_allocated', 30, 38)),
135       # expected value: 56380288 (x86/Linux) (28/6/2011)
136       if_wordsize(32,
137           compiler_stats_range_field('bytes allocated', 124952112, 10)),
138       # expected value: 73259544 (amd64/Linux) (28/6/2011):
139       if_wordsize(64,
140           compiler_stats_num_field('bytes allocated', 200000000,
141                                                       280000000)),
142       # expected value: 2247016 (x86/Linux) (28/6/2011):
143       if_wordsize(32,
144           compiler_stats_range_field('max_bytes_used', 5511604, 10)),
145       # expected value: 4032024 (amd64/Linux, intree) (28/6/2011):
146       if_wordsize(64,
147           compiler_stats_num_field('max_bytes_used', 10000000,
148                                                      14000000)),
149        only_ways(['normal'])
150       ],
151      compile,
152      [''])
153
154 test('T4007',
155      normal,
156      run_command,
157      ['$MAKE -s --no-print-directory T4007'])
158
159 test('T5030',
160      [# expected value: 449368924 (x86/Linux)
161       if_wordsize(32,
162           compiler_stats_range_field('bytes allocated', 196457520, 10)),
163       # expected value: 346750856 (amd64/Linux):
164       if_wordsize(64,
165           compiler_stats_num_field('bytes allocated', 300000000,
166                                                       400000000)),
167        only_ways(['normal'])
168       ],
169      compile,
170      ['-fcontext-stack=300'])
171
172 test('T5631',
173      [if_wordsize(32, # sample from x86/Linux
174           compiler_stats_range_field('bytes allocated', 392904228, 10)),
175       # expected value: 774,595,008 (amd64/Linux):
176       if_wordsize(64,
177           compiler_stats_num_field('bytes allocated', 600000000,
178                                                       900000000)),
179        only_ways(['normal'])
180       ],
181      compile,
182      [''])
183
184 test('parsing001',
185      [# expected value: ?
186       if_wordsize(32,
187           compiler_stats_range_field('bytes allocated', 274000576, 10)),
188       # expected value: 587079016 (amd64/Linux):
189       if_wordsize(64,
190           compiler_stats_num_field('bytes allocated', 540000000,
191                                                       620000000)),
192        only_ways(['normal']),
193       ],
194      compile_fail, [''])
195
196
197 test('T783',
198      [ only_ways(['normal']),  # no optimisation for this one
199       # expected value: 175,569,928 (x86/Linux)
200       if_wordsize(32,
201           compiler_stats_num_field('bytes allocated', 125000000,
202                                                       225000000)),
203       # sample: 349263216 (amd64/Linux)
204       if_wordsize(64,
205           compiler_stats_range_field('bytes allocated', 349263216, 10))
206       ],
207       compile,[''])
208
209 test('T5321Fun',
210      [ only_ways(['normal']),  # no optimisation for this one
211       # sample from x86/Linux
212       if_wordsize(32,
213           compiler_stats_range_field('bytes allocated', 296657384, 10)),
214       if_wordsize(64,
215           compiler_stats_range_field('bytes allocated', 585521080, 10))
216       ],
217       compile,[''])
218
219 test('T5321FD',
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', 213380256, 10)),
224       if_wordsize(64,
225           compiler_stats_range_field('bytes allocated', 418306336, 10))
226       ],
227       compile,[''])
228
229 test('T5642',
230      [ only_ways(['normal']),
231       if_wordsize(32, # sample from x86/Linux
232           compiler_stats_range_field('bytes allocated', 1682508520, 10)),
233       if_wordsize(64,
234           compiler_stats_range_field('bytes allocated', 3361296144, 10))
235       ],
236       compile,['-O'])
237
238 test('T5837',
239      [ only_ways(['normal']),
240       if_wordsize(32, # sample from x86/Linux
241           compiler_stats_range_field('bytes allocated', 40000000, 10)),
242
243       # sample: 3926235424 (amd64/Linux, 15/2/2012)
244       if_wordsize(64,
245           compiler_stats_range_field('bytes allocated', 79110184, 10))
246       ],
247       compile_fail,['-fcontext-stack=50'])