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', 10, 14)),
 132       # expected value: 18 (amd64/Linux):
 133       if_wordsize(64,
 134           compiler_stats_num_field('peak_megabytes_allocated', 20, 28)),
 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', 8000000,
 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      [expect_broken(5030),
 161       # expected value: 449368924 (x86/Linux)
 162       if_wordsize(32,
 163           compiler_stats_range_field('bytes allocated', 196457520, 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_range_field('bytes allocated', 274000576, 10)),
 189       # expected value: 587079016 (amd64/Linux):
 190       if_wordsize(64,
 191           compiler_stats_num_field('bytes allocated', 540000000,
 192                                                       620000000)),
 193        only_ways(['normal']),
 194       ],
 195      compile_fail, [''])
 196
 197
 198 test('T783',
 199      [ only_ways(['normal']),  # no optimisation for this one
 200       # expected value: 175,569,928 (x86/Linux)
 201       if_wordsize(32,
 202           compiler_stats_num_field('bytes allocated', 125000000,
 203                                                       225000000)),
 204       # sample: 349263216 (amd64/Linux)
 205       if_wordsize(64,
 206           compiler_stats_range_field('bytes allocated', 349263216, 10))
 207       ],
 208       compile,[''])
 209
 210 test('T5321Fun',
 211      [ only_ways(['normal']),  # no optimisation for this one
 212       # sample from x86/Linux
 213       if_wordsize(32,
 214           compiler_stats_range_field('bytes allocated', 296657384, 10)),
 215       if_wordsize(64,
 216           compiler_stats_range_field('bytes allocated', 585521080, 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', 213380256, 10)),
 225       if_wordsize(64,
 226           compiler_stats_range_field('bytes allocated', 418306336, 10))
 227       ],
 228       compile,[''])
 229
 230 test('T5642',
 231      [ only_ways(['normal']),
 232       if_wordsize(32, # sample from x86/Linux
 233           compiler_stats_range_field('bytes allocated', 1682508520, 10)),
 234       if_wordsize(64,
 235           compiler_stats_range_field('bytes allocated', 3361296144, 10))
 236       ],
 237       compile,['-O'])
 238
 239 test('T5837',
 240      [ only_ways(['normal']),
 241       if_wordsize(32, # sample from x86/Linux
 242           compiler_stats_range_field('bytes allocated', 40000000, 10)),
 243
 244       # sample: 3926235424 (amd64/Linux, 15/2/2012)
 245       if_wordsize(64,
 246           compiler_stats_range_field('bytes allocated', 79110184, 10))
 247       ],
 248       compile_fail,['-fcontext-stack=50'])