diff -r 000000000000 -r 6474c204b198 js/src/jit-test/tests/parallel/math-fcns.js
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/js/src/jit-test/tests/parallel/math-fcns.js	Wed Dec 31 06:09:35 2014 +0100
@@ -0,0 +1,82 @@
+// |jit-test| slow;
+load(libdir + "parallelarray-helpers.js");
+
+// The MathCache has 4096 entries, so ensure we overwrite at least one
+// entry by using > 4096 distinct inputs.
+
+var len = 5000;
+var iters = 100;
+
+// The problem we are trying to expose (Bugzilla 901000) is
+// a data-race on the MathCache; such a bug is inherently
+// non-deterministic.  On a 4 core Mac laptop:
+//
+// len == 10000 iters==1  replicates the problem on 2/10 runs,
+// len == 10000 iters==2  replicates the problem on 3/10 runs,
+// len == 10000 iters==5  replicates the problem on 6/10 runs,
+// len == 10000 iters==10 replicates the problem on 9/10 runs.
+//
+// len == 5000  iters==1  replicates the problem on 1/10 runs,
+// len == 5000  iters==2  replicates the problem on 4/10 runs,
+// len == 5000  iters==5  replicates the problem on 5/10 runs,
+// len == 5000  iters==10 replicates the problem on 9/10 runs.
+//
+// len == 2000  iters==1  replicates the problem on 0/10 runs,
+// len == 2000  iters==2  replicates the problem on 0/10 runs,
+// len == 2000  iters==5  replicates the problem on 0/10 runs,
+// len == 2000  iters==10 replicates the problem on 3/10 runs
+
+function check(fill) {
+  var seq = Array.build(len, fill);
+  for (var i = 0; i < iters; i++) {
+    var par = Array.buildPar(len, fill);
+    assertStructuralEq(par, seq);
+  }
+}
+
+function checkAbs(a)   { check(function (i) { return Math.abs(a[i]);   }); }
+function checkAcos(a)  { check(function (i) { return Math.acos(a[i]);  }); }
+function checkAsin(a)  { check(function (i) { return Math.asin(a[i]);  }); }
+function checkAtan(a)  { check(function (i) { return Math.atan(a[i]);  }); }
+function checkAtan2(a) { check(function (i) { return Math.atan2(a[i]); }); }
+function checkCeil(a)  { check(function (i) { return Math.ceil(a[i]);  }); }
+function checkCos(a)   { check(function (i) { return Math.cos(a[i]);   }); }
+function checkExp(a)   { check(function (i) { return Math.exp(a[i]);   }); }
+function checkFloor(a) { check(function (i) { return Math.floor(a[i]); }); }
+function checkLog(a)   { check(function (i) { return Math.log(a[i]);   }); }
+function checkRound(a) { check(function (i) { return Math.round(a[i]); }); }
+function checkSin(a)   { check(function (i) { return Math.sin(a[i]);   }); }
+function checkSqrt(a)  { check(function (i) { return Math.sqrt(a[i]);  }); }
+function checkTan(a)   { check(function (i) { return Math.tan(a[i]);   }); }
+
+function callVariousUnaryMathFunctions() {
+  // We might want to consider making this test adopt seedrandom.js
+  // and call Math.seedrandom("seed") here ...
+  // function fill(i) { return (2*Math.random())-1; }
+  // function fill(i) { return (20*Math.random())-10; }
+  //
+  // ... but its easiest to just drop the pseudo-random input entirely.
+  function fill(i) { return 10/i; }
+  var input = Array.build(len, fill);
+
+  checkAbs(input);    //print("abs");
+  checkAcos(input);   //print("acos");
+  checkAsin(input);   //print("asin");
+  checkAtan(input);   //print("atan");
+
+  checkAtan2(input);  //print("atan2");
+  checkCeil(input);   //print("ceil");
+  checkCos(input);    //print("cos");
+  checkExp(input);    //print("exp");
+
+  checkFloor(input);  //print("floor");
+  checkLog(input);    //print("log");
+  checkRound(input);  //print("round");
+  checkSin(input);    //print("sin");
+
+  checkSqrt(input);   //print("sqrt");
+  checkTan(input);    //print("tan");
+}
+
+if (getBuildConfiguration().parallelJS)
+  callVariousUnaryMathFunctions();