Convert to stats_num_field in perf/should_run

1 files changed, 82 insertions, 96 deletions

diff --git a/testsuite/tests/perf/should_run/all.T b/testsuite/tests/perf/should_run/all.T
index 4f45a70898..5b17e452c8 100644
--- a/testsuite/tests/perf/should_run/all.T
+++ b/testsuite/tests/perf/should_run/all.T
@@ -4,19 +4,19 @@
 # because the test allocates an unboxed array of doubles.
 
 test('T3586',
-     [stats_range_field('peak_megabytes_allocated', 17, 1),
-                                     # expected value: 17 (amd64/Linux)
-      stats_range_field('bytes allocated', 16835544, 5),
-                                     # expected value: 16835544 (amd64/Linux)
+     [stats_num_field('peak_megabytes_allocated', (17, 1)),
+                                 # expected value: 17 (amd64/Linux)
+      stats_num_field('bytes allocated', (16835544, 5)),
+                        # expected value: 16835544 (amd64/Linux)
       only_ways(['normal'])
       ],
      compile_and_run,
      ['-O'])
 
 test('T4830',
-     [stats_range_field('bytes allocated',  99264, 1),
-               # (amd64/Linux):            127000
-               # (amd64/Linux) 2013-02-07:  99264
+     [stats_num_field('bytes allocated', (99264, 1)),
+             # (amd64/Linux):            127000
+             # (amd64/Linux) 2013-02-07:  99264
       only_ways(['normal'])
       ],
      compile_and_run,
@@ -28,11 +28,11 @@ test('T3245', normal, compile_and_run, ['-O'])
 # a bug in hGetBufNonBlocking in 6.13 that triggered this.
 #
 test('lazy-bs-alloc',
-     [stats_range_field('peak_megabytes_allocated', 2, 1),
-                                     # expected value: 2 (amd64/Linux)
-      stats_range_field('bytes allocated', 429744, 1),
-              # (amd64/Linux):             489776
-              # (amd64/Linux) 2013-02-07:  429744
+     [stats_num_field('peak_megabytes_allocated', (2, 1)),
+                                 # expected value: 2 (amd64/Linux)
+      stats_num_field('bytes allocated', (429744, 1)),
+             # (amd64/Linux):             489776
+             # (amd64/Linux) 2013-02-07:  429744
       only_ways(['normal']),
       extra_run_opts('../../numeric/should_run/arith011.stdout'),
       ignore_output
@@ -70,15 +70,14 @@ test('T3738',
      ['-O'])
 
 test('MethSharing',
-     [stats_range_field('peak_megabytes_allocated', 1, 0),
-                                     # expected value: 1 (amd64/Linux)
-      # expected value: 2685858140 (x86/OS X):
-      when(wordsize(32),
-          stats_range_field('bytes allocated', 360940756, 5)),
-                                  # expected: 360940756 (x86/Linux)
-      when(wordsize(64),
-          stats_range_field('bytes allocated', 640067672, 5)),
-                                  # expected: 640067672 (amd64/Linux)
+     [stats_num_field('peak_megabytes_allocated', (1, 0)),
+                                 # expected value: 1 (amd64/Linux)
+      stats_num_field('bytes allocated', 
+                      [(wordsize(32), 360940756, 5),
+                    # expected value: 2685858140 (x86/OS X)
+                          # expected: 360940756 (x86/Linux)
+                       (wordsize(64), 640067672, 5)]),
+                          # expected: 640067672 (amd64/Linux)
       only_ways(['normal'])
       ],
      compile_and_run,
@@ -102,11 +101,9 @@ test('T149',
      ['$MAKE -s --no-print-directory T149'])
 
 test('T5113',
-     [
-      when(wordsize(32),
-          stats_range_field('bytes allocated', 4000000, 5)),
-      when(wordsize(64),
-          stats_range_field('bytes allocated', 8000000, 5)),
+     [stats_num_field('bytes allocated',
+                      [(wordsize(32), 4000000, 5),
+                       (wordsize(64), 8000000, 5)]),
       only_ways(['normal']),
       expect_broken(7046)
       ],
@@ -115,95 +112,87 @@ test('T5113',
 
 
 test('T4978',
-     [when(wordsize(32),
-          stats_range_field('bytes allocated', 10000000, 5)),
-      when(wordsize(64),
-          stats_range_field('bytes allocated', 10137680, 5)),
-                                     # expected value: 10137680 (amd64/Linux)
+     [stats_num_field('bytes allocated',
+                      [(wordsize(32), 10000000, 5),
+                       (wordsize(64), 10137680, 5)]),
+                    # expected value: 10137680 (amd64/Linux)
       only_ways(['normal'])
       ],
      compile_and_run,
      ['-O2'])
 
 test('T5205',
-     [when(wordsize(32),
-          stats_range_field('bytes allocated', 47088, 5)),
-                           # expected value: 47088 (x86/Darwin)
-      when(wordsize(64),
-          stats_range_field('bytes allocated', 51320, 5)),
-                           # expected value: 51320 (amd64/Linux)
+     [stats_num_field('bytes allocated',
+                      [(wordsize(32), 47088, 5),
+                    # expected value: 47088 (x86/Darwin)
+                       (wordsize(64), 51320, 5)]),
+                    # expected value: 51320 (amd64/Linux)
       only_ways(['normal', 'optasm'])
       ],
      compile_and_run,
      [''])
 
 test('T5549',
-     [when(wordsize(32),
-          stats_range_field('bytes allocated', 3362958676, 5)),
-                           # expected value: 3362958676 (Windows)
-      when(wordsize(64),
-          stats_range_field('bytes allocated', 6725846120, 5)),
-                           # expected value: 6,725,846,120 (amd64/Linux)
+     [stats_num_field('bytes allocated',
+                      [(wordsize(32), 3362958676, 5),
+                    # expected value: 3362958676 (Windows)
+                       (wordsize(64), 6725846120, 5)]),
+                    # expected value: 6725846120 (amd64/Linux)
       only_ways(['normal'])
       ],
      compile_and_run,
      ['-O'])
 
 test('T4474a',
-     [when(wordsize(32),
-          stats_range_field('bytes allocated', 1879095912, 5)),
-                           # expected value: 1879095912 (i386/OSX)
-      when(wordsize(64),
-          stats_range_field('bytes allocated', 3766493912, 5)),
-                           # expected value: 3766493912 (amd64/Linux)
+     [stats_num_field('bytes allocated',
+                      [(wordsize(32), 1879095912, 5),
+                    # expected value: 1879095912 (i386/OSX)
+                       (wordsize(64), 3766493912, 5)]),
+                    # expected value: 3766493912 (amd64/Linux)
       only_ways(['normal'])
       ],
      compile_and_run,
      ['-O'])
 test('T4474b',
-     [when(wordsize(32),
-          stats_range_field('bytes allocated', 1879095912, 5)),
-                           # expected value: 1879095912 (i386/OSX)
-      when(wordsize(64),
-          stats_range_field('bytes allocated', 3766493912, 5)),
-                           # expected value: 3766493912 (amd64/Linux)
+     [stats_num_field('bytes allocated',
+                      [(wordsize(32), 1879095912, 5),
+                    # expected value: 1879095912 (i386/OSX)
+                       (wordsize(64), 3766493912, 5)]),
+                    # expected value: 3766493912 (amd64/Linux)
       only_ways(['normal'])
       ],
      compile_and_run,
      ['-O'])
 test('T4474c',
-     [when(wordsize(32),
-          stats_range_field('bytes allocated', 1879095912, 5)),
-                           # expected value: 1879095912 (i386/OSX)
-      when(wordsize(64),
-          stats_range_field('bytes allocated', 3766493912, 5)),
-                           # expected value: 3766493912 (amd64/Linux)
+     [stats_num_field('bytes allocated',
+                      [(wordsize(32), 1879095912, 5),
+                    # expected value: 1879095912 (i386/OSX)
+                       (wordsize(64), 3766493912, 5)]),
+                    # expected value: 3766493912 (amd64/Linux)
       only_ways(['normal'])
       ],
      compile_and_run,
      ['-O'])
 
 test('T5237',
-     [when(wordsize(32),
-          stats_range_field('bytes allocated',  78328, 5)),
-                           # expected value: 78328 (i386/Linux)
-      when(wordsize(64),
-          stats_range_field('bytes allocated',  110888, 5)),
-                           # expected value: 110888 (amd64/Linux)
+     [stats_num_field('bytes allocated',
+                        [(wordsize(32), 78328, 5),
+                      # expected value: 78328 (i386/Linux)
+                         (wordsize(64), 110888, 5)]),
+                      # expected value: 110888 (amd64/Linux)
      only_ways(['normal'])
      ],
     compile_and_run,
     ['-O ' + sse2_opts])
 
 test('T5536',
-     [when(wordsize(32),
-          stats_range_field('bytes allocated', 1246287228, 5)),
-                           # expected value: 1246287228 (i386/Linux)
-      when(wordsize(64),
-          stats_range_field('bytes allocated', 892399040, 5)),
-                           # expected value: 2,492,589,480 (amd64/Linux)
-                           # 17/1/13:          892,399,040 (x86_64/Linux)
-                           #                   (new demand analyser)
+     [stats_num_field('bytes allocated',
+                      [(wordsize(32), 1246287228, 5),
+                    # expected value: 1246287228 (i386/Linux)
+                       (wordsize(64), 892399040, 5)]),
+                   # expected value: 2492589480 (amd64/Linux)
+                   # 17/1/13:         892399040 (x86_64/Linux)
+                   #                  (new demand analyser)
      extra_clean(['T5536.data']),
      ignore_output,
      only_ways(['normal'])
@@ -212,30 +201,27 @@ test('T5536',
     ['-O'])
 
 test('T7257',
-     [when(wordsize(32),
-          stats_range_field('bytes allocated', 1150000000, 10)),
-                           # expected value: 1246287228 (i386/Linux)
-      when(wordsize(32),
-          stats_range_field('peak_megabytes_allocated', 217, 5)),
-                           # 2012-10-08: 217 (x86/Linux)
-      when(wordsize(64),
-          stats_range_field('bytes allocated', 1774893760, 5)),
-                           # 2012-09-21: 1774893760 (amd64/Linux)
-      when(wordsize(64),
-          stats_range_field('peak_megabytes_allocated', 227, 5)),
-                           # 2012-09-21: 227 (amd64/Linux)
+     [stats_num_field('bytes allocated',
+                      [(wordsize(32), 1150000000, 10),
+                    # expected value: 1246287228 (i386/Linux)
+                       (wordsize(64), 1774893760, 5)]),
+                        # 2012-09-21: 1774893760 (amd64/Linux)
+      stats_num_field('peak_megabytes_allocated',
+                      [(wordsize(32), 217, 5),
+                        # 2012-10-08: 217 (x86/Linux)
+                       (wordsize(64), 227, 5)]),
+                        # 2012-09-21: 227 (amd64/Linux)
 
       only_ways(['normal'])
      ],
     compile_and_run, ['-O'])
 
 test('Conversions',
-     [when(wordsize(32),
-          stats_range_field('bytes allocated', 55316, 5)),
-                           # 2012-12-18: Guessed 64-bit value / 2
-      when(wordsize(64),
-          stats_range_field('bytes allocated', 110632, 5)),
-                           # 2012-12-18: 109608 (amd64/OS X)
+     [stats_num_field('bytes allocated',
+                      [(wordsize(32), 55316, 5),
+                        # 2012-12-18: Guessed 64-bit value / 2
+                       (wordsize(64), 110632, 5)]),
+                        # 2012-12-18: 109608 (amd64/OS X)
 
       only_ways(['normal'])
      ],
@@ -245,9 +231,9 @@ test('T7507', omit_ways(['ghci']), compile_and_run, ['-O'])
 # For 7507, stack overflow is the bad case
 
 test('T7436',
-     [stats_range_field('max_bytes_used', 60360, 1),
-           # (amd64/Linux):              127000
-           # (amd64/Linux) 2013-02-07:    60360
+     [stats_num_field('max_bytes_used', (60360, 1)),
+          # (amd64/Linux):              127000
+          # (amd64/Linux) 2013-02-07:    60360
       only_ways(['normal'])
       ],
      compile_and_run,