Bump limits for T1969
[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', 12000000, 10)),
28                                    # expected value: 11178376 (amd64/Linux)
29       if_wordsize(32,
30           compiler_stats_num_field('bytes allocated', 210000000,
31                                                       270000000)),
32                                     # expected value: 215582916 (x86/Windows)
33                                     #                 221667908 (x86/OS X)
34       if_wordsize(64,
35           compiler_stats_num_field('bytes allocated', 420000000,
36                                                       580000000)),
37                                     # 17/11/2009:     434,845,560 (amd64/Linux)
38                                     # 08/12/2009:     459,776,680 (amd64/Linux)
39                                     # 17/05/2010:     519,377,728 (amd64/Linux)
40                                     # 05/08/2011:     561,382,568 (amd64/OS X)
41       only_ways(['normal']),
42       extra_hc_opts('-dcore-lint')
43           # Leave -dcore-lint on for this one test, so that we have something
44           # that will catch a regression in -dcore-lint performance.
45       ],
46      compile,
47      [''])
48
49 # This one tests for the space leak in the native code generator,
50 # where it holds onto the entire asm output until the end.  The space
51 # leak reappears from time to time, so it's a good idea to have a test
52 # for it.  The residency of this test will jump by 10MB to 40MB or so
53 # on x86-64 if the space leak appears.
54
55 # Only run this one if we have an NCG:
56 if 'optasm' in config.compile_ways:
57    conf_3294 = only_ways(['normal'])
58 else:
59    conf_3294 = skip
60
61 test('T3294',
62      [if_wordsize(32,
63           compiler_stats_num_field('max_bytes_used', 14000000,
64                                                      20000000)),
65                                    # expected value: 17725476 (x86/OS X)
66                                    #                 14593500 (Windows)
67       if_wordsize(64,
68           compiler_stats_num_field('max_bytes_used', 26000000,
69                                                      37000000)),
70                                    # expected value: 32 478 408 (amd64/Linux)
71                                    # (but varies a lot, depending on when
72                                    # we GC relative to the peak).
73                                    # (MCB: consistently reaching ~35 375 912 for
74                                    # me lately on amd64/Darwin)
75       if_wordsize(32,
76           compiler_stats_num_field('bytes allocated', 650000000,
77                                                       750000000)),
78                                     # expected value: 815479800  (x86/Linux)
79       if_wordsize(64,
80           compiler_stats_num_field('bytes allocated', 1200000000,
81                                                       1500000000)),
82                                     # expected value: 1357587088 (amd64/Linux)
83       conf_3294
84       ],
85      compile,
86      [''])
87
88 test('T4801',
89      [ # expect_broken(5224),
90        # temporarily unbroken (#5227)
91       if_wordsize(32,
92           compiler_stats_range_field('peak_megabytes_allocated', 30, 10)),
93       if_wordsize(64, # sample from (amd64/Linux):
94           compiler_stats_range_field('peak_megabytes_allocated', 47, 10)),
95       # expected value: 58 (amd64/OS X):
96       if_platform('x86_64-apple-darwin',
97           compiler_stats_num_field('peak_megabytes_allocated', 56, 60)),
98       # expected value: 228286660 (x86/OS X)
99       if_wordsize(32,
100           compiler_stats_range_field('bytes allocated', 185669232, 10)),
101       if_wordsize(64, # (amd64/Linux):
102           compiler_stats_range_field('bytes allocated', 360243576, 10)),
103       # expected value: 510938976 (amd64/OS X):
104       if_platform('x86_64-apple-darwin',
105           compiler_stats_num_field('bytes allocated', 490000000,
106                                                       530000000)),
107       if_wordsize(32,
108       #                    expected value: x86/OS X:  9651948
109           compiler_stats_num_field('max_bytes_used',  9000000,
110                                                      12000000)),
111       # expected value: 18188272 (amd64/Linux)
112       #                 10290952 (windows)
113       if_wordsize(64,
114           compiler_stats_num_field('max_bytes_used', 15000000,
115                                                      20000000)),
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      [
127       # expected value: 9 (x86/Linux 30-03-2011):
128       if_wordsize(32,
129           compiler_stats_num_field('peak_megabytes_allocated', 7, 12)),
130       # expected value: 18 (amd64/Linux):
131       if_wordsize(64,
132           compiler_stats_num_field('peak_megabytes_allocated', 9, 16)),
133       # expected value: 56380288 (x86/Linux) (28/6/2011)
134       if_wordsize(32,
135           compiler_stats_range_field('bytes allocated', 39800820, 10)),
136       # expected value: 73259544 (amd64/Linux) (28/6/2011):
137       if_wordsize(64,
138           compiler_stats_num_field('bytes allocated', 60000000,
139                                                       80000000)),
140       # expected value: 2247016 (x86/Linux) (28/6/2011):
141       if_wordsize(32,
142           compiler_stats_num_field('max_bytes_used', 2000000,
143                                                      3000000)),
144       # expected value: 4032024 (amd64/Linux, intree) (28/6/2011):
145       if_wordsize(64,
146           compiler_stats_num_field('max_bytes_used', 3000000,
147                                                      5000000)),
148        only_ways(['normal'])
149       ],
150      compile,
151      [''])
152
153 test('T4007',
154      normal,
155      run_command,
156      ['$MAKE -s --no-print-directory T4007'])
157
158 test('T5030',
159      [# expected value: 449368924 (x86/Linux)
160       if_wordsize(32,
161           compiler_stats_range_field('bytes allocated', 176193448, 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_num_field('bytes allocated', 280000000,
187                                                       320000000)),
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', 341591280, 10)),
214       # expected value: 669165280 (amd64/Linux):
215       if_wordsize(64,
216           compiler_stats_range_field('bytes allocated', 669165280, 10))
217       ],
218       compile,[''])
219
220 test('T5321FD',
221      [ only_ways(['normal']),  # no optimisation for this one
222       # sample from x86/Linux
223       if_wordsize(32,
224           compiler_stats_range_field('bytes allocated', 257175456, 10)),
225       # expected value: 500642456 (amd64/Linux):
226       if_wordsize(64,
227           compiler_stats_range_field('bytes allocated', 500642456, 10))
228       ],
229       compile,[''])
230
231 test('T5642',
232      [ only_ways(['normal']),
233       if_wordsize(32, # sample from x86/Linux
234           compiler_stats_range_field('bytes allocated', 1893427932, 10)),
235
236       # sample: 3926235424 (amd64/Linux, 15/2/2012)
237       if_wordsize(64,
238           compiler_stats_range_field('bytes allocated', 3926235424, 10))
239       ],
240       compile,['-O'])