diff -r 000000000000 -r 6474c204b198 js/src/tests/parsemark.py
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/js/src/tests/parsemark.py	Wed Dec 31 06:09:35 2014 +0100
@@ -0,0 +1,154 @@
+#!/usr/bin/env python
+
+"""%prog [options] shellpath dirpath
+
+Pulls performance data on parsing via the js shell.
+Displays the average number of milliseconds it took to parse each file.
+
+For comparison, something apparently approximating a t-test is performed:
+"Faster" means that:
+
+    t_baseline_goodrun = (t_baseline_avg - t_baseline_stddev)
+    t_current_badrun = (t_current_avg + t_current_stddev) 
+    t_current_badrun < t_baseline_goodrun
+
+Effectively, a bad run from the current data is better than a good run from the
+baseline data, we're probably faster. A similar computation is used for
+determining the "slower" designation.
+
+Arguments:
+  shellpath             executable JavaScript shell
+  dirpath               directory filled with parsilicious js files
+"""
+
+import math
+import optparse
+import os
+import subprocess as subp
+import sys
+from string import Template
+
+try:
+    import compare_bench
+except ImportError:
+    compare_bench = None
+
+
+_DIR = os.path.dirname(__file__)
+JS_CODE_TEMPLATE = Template("""
+if (typeof snarf !== 'undefined') read = snarf
+var contents = read("$filepath");
+for (var i = 0; i < $warmup_run_count; i++)
+    parse(contents);
+var results = [];
+for (var i = 0; i < $real_run_count; i++) {
+    var start = new Date();
+    parse(contents);
+    var end = new Date();
+    results.push(end - start);
+}
+print(results);
+""")
+
+
+def gen_filepaths(dirpath, target_ext='.js'):
+    for filename in os.listdir(dirpath):
+        if filename.endswith(target_ext):
+            yield os.path.join(dirpath, filename)
+
+
+def avg(seq):
+    return sum(seq) / len(seq)
+
+
+def stddev(seq, mean):
+    diffs = ((float(item) - mean) ** 2 for item in seq)
+    return math.sqrt(sum(diffs) / len(seq))
+
+
+def bench(shellpath, filepath, warmup_runs, counted_runs, stfu=False):
+    """Return a list of milliseconds for the counted runs."""
+    assert '"' not in filepath
+    code = JS_CODE_TEMPLATE.substitute(filepath=filepath,
+            warmup_run_count=warmup_runs, real_run_count=counted_runs)
+    proc = subp.Popen([shellpath, '-e', code], stdout=subp.PIPE)
+    stdout, _ = proc.communicate()
+    milliseconds = [float(val) for val in stdout.split(',')]
+    mean = avg(milliseconds)
+    sigma = stddev(milliseconds, mean)
+    if not stfu:
+        print 'Runs:', [int(ms) for ms in milliseconds]
+        print 'Mean:', mean
+        print 'Stddev: %.2f (%.2f%% of mean)' % (sigma, sigma / mean * 100)
+    return mean, sigma
+
+
+def parsemark(filepaths, fbench, stfu=False):
+    """:param fbench: fbench(filename) -> float"""
+    bench_map = {} # {filename: (avg, stddev)}
+    for filepath in filepaths:
+        filename = os.path.split(filepath)[-1]
+        if not stfu:
+            print 'Parsemarking %s...' % filename
+        bench_map[filename] = fbench(filepath)
+    print '{'
+    for i, (filename, (avg, stddev)) in enumerate(bench_map.iteritems()):
+        assert '"' not in filename
+        fmt = '    %30s: {"average_ms": %6.2f, "stddev_ms": %6.2f}'
+        if i != len(bench_map) - 1:
+            fmt += ','
+        filename_str = '"%s"' % filename
+        print fmt % (filename_str, avg, stddev)
+    print '}'
+    return dict((filename, dict(average_ms=avg, stddev_ms=stddev))
+            for filename, (avg, stddev) in bench_map.iteritems())
+
+
+def main():
+    parser = optparse.OptionParser(usage=__doc__.strip())
+    parser.add_option('-w', '--warmup-runs', metavar='COUNT', type=int,
+            default=5, help='used to minimize test instability [%default]')
+    parser.add_option('-c', '--counted-runs', metavar='COUNT', type=int,
+            default=50, help='timed data runs that count towards the average [%default]')
+    parser.add_option('-s', '--shell', metavar='PATH', help='explicit shell '
+            'location; when omitted, will look in likely places')
+    parser.add_option('-b', '--baseline', metavar='JSON_PATH',
+            dest='baseline_path', help='json file with baseline values to '
+            'compare against')
+    parser.add_option('-q', '--quiet', dest='stfu', action='store_true',
+            default=False, help='only print JSON to stdout [%default]')
+    options, args = parser.parse_args()
+    try:
+        shellpath = args.pop(0)
+    except IndexError:
+        parser.print_help()
+        print
+        print >> sys.stderr, 'error: shellpath required'
+        return -1
+    try:
+        dirpath = args.pop(0)
+    except IndexError:
+        parser.print_help()
+        print
+        print >> sys.stderr, 'error: dirpath required'
+        return -1
+    if not shellpath or not os.path.exists(shellpath):
+        print >> sys.stderr, 'error: could not find shell:', shellpath
+        return -1
+    if options.baseline_path:
+        if not os.path.isfile(options.baseline_path):
+            print >> sys.stderr, 'error: baseline file does not exist'
+            return -1
+        if not compare_bench:
+            print >> sys.stderr, 'error: JSON support is missing, cannot compare benchmarks'
+            return -1
+    benchfile = lambda filepath: bench(shellpath, filepath,
+            options.warmup_runs, options.counted_runs, stfu=options.stfu)
+    bench_map = parsemark(gen_filepaths(dirpath), benchfile, options.stfu)
+    if options.baseline_path:
+        compare_bench.compare_immediate(bench_map, options.baseline_path)
+    return 0
+
+
+if __name__ == '__main__':
+    sys.exit(main())