The Tor Browser: js/src/jit-test/tests/basic/createMandelSet.js@6474c204b198 (annotated)

js/src/jit-test/tests/basic/createMandelSet.js@6474c204b198 (annotated)

js/src/jit-test/tests/basic/createMandelSet.js

Wed, 31 Dec 2014 06:09:35 +0100

author: Michael Schloh von Bennewitz <michael@schloh.com>
date: Wed, 31 Dec 2014 06:09:35 +0100
changeset 0: 6474c204b198
permissions: -rw-r--r--

Cloned upstream origin tor-browser at tor-browser-31.3.0esr-4.5-1-build1
revision ID fc1c9ff7c1b2defdbc039f12214767608f46423f for hacking purpose.

 // |jit-test| slow;
 // XXXbz I would dearly like to wrap it up into a function to avoid polluting
 // the global scope, but the function ends up heavyweight, and then we lose on
 // the jit.
 load(libdir + "mandelbrot-results.js");
 //function testMandelbrotAll() {
   // Configuration options that affect which codepaths we follow.
   var doImageData = true;
   var avoidSparseArray = true;
   // Control of iteration numbers and sizing.  We'll do
   // scaler * colorNames.length iterations or so before deciding that we
   // don't escape.
   const scaler = 5;
   const numRows = 600;
   const numCols = 600;
   const colorNames = [
     "black",
     "green",
     "blue",
     "red",
     "purple",
     "orange",
     "cyan",
     "yellow",
     "magenta",
     "brown",
     "pink",
     "chartreuse",
     "darkorange",
     "crimson",
     "gray",
     "deeppink",
     "firebrick",
     "lavender",
     "lawngreen",
     "lightsalmon",
     "lime",
     "goldenrod"
   ];
   const threshold = (colorNames.length - 1) * scaler;
   // Now set up our colors
   var colors = [];
   // 3-part for loop (iterators buggy, we will add a separate test for them)
   for (var colorNameIdx = 0; colorNameIdx < colorNames.length; ++colorNameIdx) {
   //for (var colorNameIdx in colorNames) {
     colorNameIdx = parseInt(colorNameIdx);
     colors.push([colorNameIdx, colorNameIdx, colorNameIdx, 0]);
   }
   // Storage for our point data
   var points;
   var scratch = {};
   var scratchZ = {};
   function complexMult(a, b) {
     var newr = a.r * b.r - a.i * b.i;
     var newi = a.r * b.i + a.i * b.r;
     scratch.r = newr;
     scratch.i = newi;
     return scratch;
   }
   function complexAdd(a, b) {
     scratch.r = a.r + b.r;
     scratch.i = a.i + b.i;
     return scratch;
   }
   function abs(a) {
     return Math.sqrt(a.r * a.r + a.i * a.i);
   }
   function escapeAbsDiff(normZ, absC) {
     var absZ = Math.sqrt(normZ);
     return normZ > absZ + absC;
   }
   function escapeNorm2(normZ) {
     return normZ > 4;
   }
   function fuzzyColors(i) {
     return Math.floor(i / scaler) + 1;
   }
   function moddedColors(i) {
     return (i % (colorNames.length - 1)) + 1;
   }
   function computeEscapeSpeedObjects(real, imag) {
     var c = { r: real, i: imag }
     scratchZ.r = scratchZ.i = 0;
     var absC = abs(c);
     for (var i = 0; i < threshold; ++i) {
       scratchZ = complexAdd(c, complexMult(scratchZ, scratchZ));
       if (escape(scratchZ.r * scratchZ.r + scratchZ.i * scratchZ.i,
                  absC)) {
         return colorMap(i);
       }
     }
     return 0;
   }
   function computeEscapeSpeedOneObject(real, imag) {
     // fold in the fact that we start with 0
     var r = real;
     var i = imag;
     var absC = abs({r: real, i: imag});
     for (var j = 0; j < threshold; ++j) {
       var r2 = r * r;
       var i2 = i * i;
       if (escape(r2 + i2, absC)) {
         return colorMap(j);
       }
       i = 2 * r * i + imag;
       r = r2 - i2 + real;
     }
     return 0;
   }
   function computeEscapeSpeedDoubles(real, imag) {
     // fold in the fact that we start with 0
     var r = real;
     var i = imag;
     var absC = Math.sqrt(real * real + imag * imag);
     for (var j = 0; j < threshold; ++j) {
       var r2 = r * r;
       var i2 = i * i;
       if (escape(r2 + i2, absC)) {
         return colorMap(j);
       }
       i = 2 * r * i + imag;
       r = r2 - i2 + real;
     }
     return 0;
   }
   var computeEscapeSpeed = computeEscapeSpeedDoubles;
   var escape = escapeNorm2;
   var colorMap = fuzzyColors;
   function addPointOrig(pointArray, n, i, j) {
     if (!points[n]) {
       points[n] = [];
       points[n].push([i, j, 1, 1]);
     } else {
       var point = points[n][points[n].length-1];
       if (point[0] == i && point[1] == j - point[3]) {
         ++point[3];
       } else {
         points[n].push([i, j, 1, 1]);
       }
     }
   }
   function addPointImagedata(pointArray, n, col, row) {
     var slotIdx = ((row * numCols) + col) * 4;
     pointArray[slotIdx] = colors[n][0];
     pointArray[slotIdx+1] = colors[n][1];
     pointArray[slotIdx+2] = colors[n][2];
     pointArray[slotIdx+3] = colors[n][3];
   }
   function createMandelSet() {
     var realRange = { min: -2.1, max: 1 };
     var imagRange = { min: -1.5, max: 1.5 };
     var addPoint;
     if (doImageData) {
       addPoint = addPointImagedata;
       points = new Array(4*numCols*numRows);
       if (avoidSparseArray) {
         for (var idx = 0; idx < 4*numCols*numRows; ++idx) {
           points[idx] = 0;
         }
       }
     } else {
       addPoint = addPointOrig;
       points = [];
     }
     var realStep = (realRange.max - realRange.min)/numCols;
     var imagStep = (imagRange.min - imagRange.max)/numRows;
     for (var i = 0, curReal = realRange.min;
          i < numCols;
          ++i, curReal += realStep) {
       for (var j = 0, curImag = imagRange.max;
            j < numRows;
            ++j, curImag += imagStep) {
         var n = computeEscapeSpeed(curReal, curImag);
         addPoint(points, n, i, j)
       }
     }
     var result;
     if (doImageData) {
       if (colorMap == fuzzyColors) {
         result = mandelbrotImageDataFuzzyResult;
       } else {
         result = mandelbrotImageDataModdedResult;
       }
     } else {
       result = mandelbrotNoImageDataResult;
     }
     return points.toSource() == result;
   }
   const escapeTests = [ escapeAbsDiff ];
   const colorMaps = [ fuzzyColors, moddedColors ];
   const escapeComputations = [ computeEscapeSpeedObjects,
                                computeEscapeSpeedOneObject,
                                computeEscapeSpeedDoubles ];
   // Test all possible escape-speed generation codepaths, using the
   // imageData + sparse array avoidance storage.
   doImageData = true;
   avoidSparseArray = true;
   for (var escapeIdx in escapeTests) {
     escape = escapeTests[escapeIdx];
     for (var colorMapIdx in colorMaps) {
       colorMap = colorMaps[colorMapIdx];
       for (var escapeComputationIdx in escapeComputations) {
         computeEscapeSpeed = escapeComputations[escapeComputationIdx];
 	assertEq(createMandelSet(), true);
       }
     }
   }
   // Test all possible storage strategies. Note that we already tested
   // doImageData == true with avoidSparseArray == true.
   escape = escapeAbsDiff;
   colorMap = fuzzyColors; // This part doesn't really matter too much here
   computeEscapeSpeed = computeEscapeSpeedDoubles;
   doImageData = true;
   avoidSparseArray = false;
   assertEq(createMandelSet(), true);
   escape = escapeNorm2;
   doImageData = false;  // avoidSparseArray doesn't matter here
   assertEq(createMandelSet(), true);
 //}
 //testMandelbrotAll();