update max_bytes_used for T4801 on 64-bit
[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: 10290952 (windows)
114       if_wordsize(64,
115           compiler_stats_range_field('max_bytes_used', 20835240, 15)),
116       # expected value: 20486256 (amd64/OS X):
117       if_platform('x86_64-apple-darwin',
118           compiler_stats_num_field('max_bytes_used', 20000000,
119                                                      23000000)),
120        only_ways(['normal'])
121       ],
122      compile,
123      [''])
124
125 test('T3064',
126      [# expect_broken( 3064 ),
127       # expected value: 9 (x86/Linux 30-03-2011):
128       if_wordsize(32,
129           compiler_stats_range_field('peak_megabytes_allocated', 10, 14)),
130       # expected value: 18 (amd64/Linux):
131       if_wordsize(64,
132           compiler_stats_num_field('peak_megabytes_allocated', 20, 28)),
133       # expected value: 56380288 (x86/Linux) (28/6/2011)
134       if_wordsize(32,
135           compiler_stats_range_field('bytes allocated', 124952112, 10)),
136       # expected value: 73259544 (amd64/Linux) (28/6/2011):
137       if_wordsize(64,
138           compiler_stats_num_field('bytes allocated', 200000000,
139                                                       280000000)),
140       # expected value: 2247016 (x86/Linux) (28/6/2011):
141       if_wordsize(32,
142           compiler_stats_range_field('max_bytes_used', 5511604, 10)),
143       # expected value: 4032024 (amd64/Linux, intree) (28/6/2011):
144       if_wordsize(64,
145           compiler_stats_num_field('max_bytes_used', 8000000,
146                                                      14000000)),
147        only_ways(['normal'])
148       ],
149      compile,
150      [''])
151
152 test('T4007',
153      normal,
154      run_command,
155      ['$MAKE -s --no-print-directory T4007'])
156
157 test('T5030',
158      [expect_broken(5030),
159       # expected value: 449368924 (x86/Linux)
160       if_wordsize(32,
161           compiler_stats_range_field('bytes allocated', 196457520, 10)),
162       # expected value: 346750856 (amd64/Linux):
163       if_wordsize(64,
164           compiler_stats_num_field('bytes allocated', 300000000,
165                                                       400000000)),
166        only_ways(['normal'])
167       ],
168      compile,
169      ['-fcontext-stack=300'])
170
171 test('T5631',
172      [if_wordsize(32, # sample from x86/Linux
173           compiler_stats_range_field('bytes allocated', 392904228, 10)),
174       # expected value: 774,595,008 (amd64/Linux):
175       if_wordsize(64,
176           compiler_stats_num_field('bytes allocated', 600000000,
177                                                       900000000)),
178        only_ways(['normal'])
179       ],
180      compile,
181      [''])
182
183 test('parsing001',
184      [# expected value: ?
185       if_wordsize(32,
186           compiler_stats_range_field('bytes allocated', 274000576, 10)),
187       # expected value: 587079016 (amd64/Linux):
188       if_wordsize(64,
189           compiler_stats_num_field('bytes allocated', 540000000,
190                                                       620000000)),
191        only_ways(['normal']),
192       ],
193      compile_fail, [''])
194
195
196 test('T783',
197      [ only_ways(['normal']),  # no optimisation for this one
198       # expected value: 175,569,928 (x86/Linux)
199       if_wordsize(32,
200           compiler_stats_num_field('bytes allocated', 125000000,
201                                                       225000000)),
202       # sample: 349263216 (amd64/Linux)
203       if_wordsize(64,
204           compiler_stats_range_field('bytes allocated', 349263216, 10))
205       ],
206       compile,[''])
207
208 test('T5321Fun',
209      [ only_ways(['normal']),  # no optimisation for this one
210       # sample from x86/Linux
211       if_wordsize(32,
212           compiler_stats_range_field('bytes allocated', 296657384, 10)),
213       if_wordsize(64,
214           compiler_stats_range_field('bytes allocated', 585521080, 10))
215       ],
216       compile,[''])
217
218 test('T5321FD',
219      [ only_ways(['normal']),  # no optimisation for this one
220       # sample from x86/Linux
221       if_wordsize(32,
222           compiler_stats_range_field('bytes allocated', 213380256, 10)),
223       if_wordsize(64,
224           compiler_stats_range_field('bytes allocated', 418306336, 10))
225       ],
226       compile,[''])
227
228 test('T5642',
229      [ only_ways(['normal']),
230       if_wordsize(32, # sample from x86/Linux
231           compiler_stats_range_field('bytes allocated', 1682508520, 10)),
232       if_wordsize(64,
233           compiler_stats_range_field('bytes allocated', 3361296144, 10))
234       ],
235       compile,['-O'])
236
237 test('T5837',
238      [ only_ways(['normal']),
239       if_wordsize(32, # sample from x86/Linux
240           compiler_stats_range_field('bytes allocated', 40000000, 10)),
241
242       # sample: 3926235424 (amd64/Linux, 15/2/2012)
243       if_wordsize(64,
244           compiler_stats_range_field('bytes allocated', 79110184, 10))
245       ],
246       compile_fail,['-fcontext-stack=50'])
247
248 test('T6048',
249      [ only_ways(['optasm']),
250       if_wordsize(32, # sample from x86/Linux
251           compiler_stats_range_field('bytes allocated', 38000000, 10)),
252
253       if_wordsize(64,
254           compiler_stats_range_field('bytes allocated', 67328320, 10))
255       ],
256       compile,[''])