Update some perf bounds that have improved
[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', 47, 10)),
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_num_field('peak_megabytes_allocated', 7, 12)),
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', 39800820, 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_num_field('max_bytes_used', 2000000,
145                                                      3000000)),
146       # expected value: 4032024 (amd64/Linux, intree) (28/6/2011):
147       if_wordsize(64,
148           compiler_stats_num_field('max_bytes_used', 10000000,
149                                                      14000000)),
150        only_ways(['normal'])
151       ],
152      compile,
153      [''])
154
155 test('T4007',
156      normal,
157      run_command,
158      ['$MAKE -s --no-print-directory T4007'])
159
160 test('T5030',
161      [# expected value: 449368924 (x86/Linux)
162       if_wordsize(32,
163           compiler_stats_range_field('bytes allocated', 176193448, 10)),
164       # expected value: 346750856 (amd64/Linux):
165       if_wordsize(64,
166           compiler_stats_num_field('bytes allocated', 300000000,
167                                                       400000000)),
168        only_ways(['normal'])
169       ],
170      compile,
171      ['-fcontext-stack=300'])
172
173 test('T5631',
174      [if_wordsize(32, # sample from x86/Linux
175           compiler_stats_range_field('bytes allocated', 392904228, 10)),
176       # expected value: 774,595,008 (amd64/Linux):
177       if_wordsize(64,
178           compiler_stats_num_field('bytes allocated', 600000000,
179                                                       900000000)),
180        only_ways(['normal'])
181       ],
182      compile,
183      [''])
184
185 test('parsing001',
186      [# expected value: ?
187       if_wordsize(32,
188           compiler_stats_num_field('bytes allocated', 280000000,
189                                                       320000000)),
190       # expected value: 587079016 (amd64/Linux):
191       if_wordsize(64,
192           compiler_stats_num_field('bytes allocated', 540000000,
193                                                       620000000)),
194        only_ways(['normal']),
195       ],
196      compile_fail, [''])
197
198
199 test('T783',
200      [ only_ways(['normal']),  # no optimisation for this one
201       # expected value: 175,569,928 (x86/Linux)
202       if_wordsize(32,
203           compiler_stats_num_field('bytes allocated', 125000000,
204                                                       225000000)),
205       # sample: 349263216 (amd64/Linux)
206       if_wordsize(64,
207           compiler_stats_range_field('bytes allocated', 349263216, 10))
208       ],
209       compile,[''])
210
211 test('T5321Fun',
212      [ only_ways(['normal']),  # no optimisation for this one
213       # sample from x86/Linux
214       if_wordsize(32,
215           compiler_stats_range_field('bytes allocated', 341591280, 10)),
216       # expected value: 669165280 (amd64/Linux):
217       if_wordsize(64,
218           compiler_stats_range_field('bytes allocated', 585521080, 10))
219       ],
220       compile,[''])
221
222 test('T5321FD',
223      [ only_ways(['normal']),  # no optimisation for this one
224       # sample from x86/Linux
225       if_wordsize(32,
226           compiler_stats_range_field('bytes allocated', 257175456, 10)),
227       # expected value: 500642456 (amd64/Linux):
228       if_wordsize(64,
229           compiler_stats_range_field('bytes allocated', 418306336, 10))
230       ],
231       compile,[''])
232
233 test('T5642',
234      [ only_ways(['normal']),
235       if_wordsize(32, # sample from x86/Linux
236           compiler_stats_range_field('bytes allocated', 1893427932, 10)),
237
238       # sample: 3926235424 (amd64/Linux, 15/2/2012)
239       if_wordsize(64,
240           compiler_stats_range_field('bytes allocated', 3361296144, 10))
241       ],
242       compile,['-O'])