The Tor Browser: js/src/parjs-benchmarks/rectarray.js@b8a032363ba2 (annotated)

js/src/parjs-benchmarks/rectarray.js@b8a032363ba2 (annotated)

js/src/parjs-benchmarks/rectarray.js

Thu, 22 Jan 2015 13:21:57 +0100

author: Michael Schloh von Bennewitz <michael@schloh.com>
date: Thu, 22 Jan 2015 13:21:57 +0100
branch: TOR_BUG_9701
changeset 15: b8a032363ba2
permissions: -rw-r--r--

Incorporate requested changes from Mozilla in review:
https://bugzilla.mozilla.org/show_bug.cgi?id=1123480#c6

 // -*- mode: js2; indent-tabs-mode: nil; -*-
 // A RectArray<X,k> is a subclass of Array with 'width', 'height',
 // and 'payload' properties (where payload holds 'k').
 // properties, and 'width*height*k' elements (each an X) in the array.
 //
 // A RectTypedByteArray<k> is a subclass of ArrayBuffer with 'width'
 // and 'height' properties, and 'width*height*k' bytes in the buffer.
 //
 // The 'payload' property is initialized with the value of 'k'.
 //
 // (Felix would have used Array or ArrayView, but for the following bug:
 //   Bug 695438 - TypedArrays don't support new named properties
 //   https://bugzilla.mozilla.org/show_bug.cgi?id=695438
 //  and so he is resorting to extending ArrayBuffer instead.)
 //
 // Both classes add a .get(x,y[,k]) method that eases access to the
 // contents, and a set(x,y[,k],value) method that eases modifying
 // their entries.
 //
 // In addition, for those who prefer functional-style,
 // RectArray.build,
 // and RectByteTypedArray.build
 var RectArray, RectByteTypedArray;
 // This is a variant of RectArray that supports the same interface,
 // but instead of attempting to extend Array (a practice fraught with
 // peril), it instead makes a wrapper around another array.
 var WrapArray, WrapByteTypedArray;
 (function (){
    function defineReadOnly(x, name, value) {
      Object.defineProperty(x, name, {
                              value: value,
                              writable: false,
                              enumerable: true,
                              configurable: true });
    }
    RectArray = function RectArray(w,h,k) {
      if (k === undefined)
        k = 1;
      this.length = w*h*k;
      defineReadOnly(this, "width", w);
      defineReadOnly(this, "height", h);
      defineReadOnly(this, "payload", k);
    };
    RectByteTypedArray = function RectByteTypedArray(w,h,k) {
      if (k === undefined)
        k = 1;
      ArrayBuffer.call(this, w*h*k);
      defineReadOnly(this, "width", w);
      defineReadOnly(this, "height", h);
      defineReadOnly(this, "payload", k);
    };
    WrapArray = function WrapArray(w,h,k) {
      if (k === undefined)
        k = 1;
      this.backingArray = new Array(w*h*k);
      defineReadOnly(this, "width", w);
      defineReadOnly(this, "height", h);
      defineReadOnly(this, "payload", k);
    };
    WrapByteTypedArray = function WrapByteTypedArray(w,h,k) {
      if (k === undefined)
        k = 1;
      this.backingArray = new Uint8Array(new ArrayBuffer(w*h*k));
      defineReadOnly(this, "width", w);
      defineReadOnly(this, "height", h);
      defineReadOnly(this, "payload", k);
    };
    WrapArray.prototype.slice = function(a,b) this.backingArray.slice(a,b);
    WrapArray.prototype.join  = function(a) this.backingArray.join(a);
    RectArray.prototype = new Array();
    RectByteTypedArray.prototype = new ArrayBuffer();
    RectArray.prototype.get = function get(x,y,j) {
      if (j === undefined) j = 0;
      return this[(y*this.width+x)*this.payload+j];
    };
    RectArray.prototype.set = function set(x,y,j,value) {
      if (value === undefined) {
        value = j;
        j = 0;
      }
      this[(y*this.width+x)*this.payload+j] = value;
    };
    RectByteTypedArray.prototype.get = function get(x,y,j) {
      if (j === undefined) j = 0;
      return (new Uint8Array(this))[(y*this.width+x)*this.payload+j];
    };
    RectByteTypedArray.prototype.set = function set(x,y,j,value) {
      if (value === undefined) {
        value = j;
        j = 0;
      }
      (new Uint8Array(this))[(y*this.width+x)*this.payload+j] = value;
    };
    WrapArray.prototype.get = function get(x,y,j) {
      if (j === undefined) j = 0;
      return this.backingArray[(y*this.width+x)*this.payload+j];
    };
    WrapArray.prototype.set = function set(x,y,j,value) {
      if (value === undefined) {
        value = j;
        j = 0;
      }
      this.backingArray[(y*this.width+x)*this.payload+j] = value;
    };
    WrapByteTypedArray.prototype.get = function get(x,y,j) {
      if (j === undefined) j = 0;
      return this.backingArray[(y*this.width+x)*this.payload+j];
    };
    WrapByteTypedArray.prototype.set = function set(x,y,j,value) {
      if (value === undefined) {
        value = j;
        j = 0;
      }
      this.backingArray[(y*this.width+x)*this.payload+j] = value;
    };
    function viewToSource(view, width, height, payload) {
      var ret = "[";
      var i=0;
      var matrixNeedsNewline = false;
      for (var row=0; row < height; row++) {
        if (matrixNeedsNewline)
          ret += ",\n ";
        ret += "[";
        var rowNeedsComma = false;
        for (var x=0; x < width; x++) {
          if (rowNeedsComma)
            ret += ", ";
          if (payload == 1) {
            if (view[i] !== undefined)
              ret += view[i];
            i++;
          } else {
            var entryNeedsComma = false;
            ret += "(";
            for (var k=0; k < payload; k++) {
              // Might be inefficient (does JavaScript have
              // StringBuffers?, or use them internally, like Tamarin?)
              if (entryNeedsComma)
                ret += ", ";
              if (view[i] !== undefined)
                ret += view[i];
              entryNeedsComma = true;
              i++;
            }
            ret += ")";
          }
          rowNeedsComma = true;
        }
        ret += "]";
        matrixNeedsNewline = true;
      }
      ret += "]";
      return ret;
    }
    RectArray.prototype.toSource = function toSource() {
      return viewToSource(this,
                          this.width, this.height, this.payload);
    };
    RectByteTypedArray.prototype.toSource = function toSource() {
      return viewToSource(new Uint8Array(this),
                          this.width, this.height, this.payload);
    };
    WrapArray.prototype.toSource = function toSource() {
      return viewToSource(this.backingArray,
                          this.width, this.height, this.payload);
    };
    WrapByteTypedArray.prototype.toSource = function toSource() {
      return viewToSource(this.backingArray,
                          this.width, this.height, this.payload);
    };
    RectArray.prototype.map = function map(f) {
      var ret = Array.map(this, f);
      ret.__proto__ = RectArray.prototype;
      defineReadOnly(ret, "width", this.width);
      defineReadOnly(ret, "height", this.height);
      defineReadOnly(ret, "payload", this.payload);
      return ret;
    };
    WrapArray.prototype.map = function map(f) {
      var ret = new WrapArray(this.width, this.height, this.payload);
      ret.backingArray = this.backingArray.map(f);
      return ret;
    };
    // (Array<X>|ArrayView<X>) Nat Nat Nat (Nat Nat Nat -> X) -> void
    function fillArrayView(view, width, height, k, fill) {
      var i = 0;
      for (var y=0; y < height; y++) {
        for (var x=0; x < width; x++) {
          for (var j=0; j < k; j++) {
            view[i++] = fill(x, y, j);
          }
        }
      }
    }
    // Nat Nat (Nat Nat [Nat] -> X) -> RectArray<X,1>
    RectArray.build =
      function buildRectArray1(width, height, fill) {
        var a = new RectArray(width, height, 1);
        fillArrayView(a, width, height, 1, fill);
        return a;
      };
    RectArray.buildA =
      function buildRectArrayA(width, height, fill) {
        var a = new Array(width*height);
        fillArrayView(a, width, height, 1, fill);
        a.width = width;
        a.height = height;
        a.payload = 1;
        function F() { }
        F.prototype = RectArray.prototype;
        a.__proto__ = new F();
        return a;
      };
    // Nat Nat (Nat Nat Nat -> X) -> RectArray<X,4>
    RectArray.build4 =
      function buildRectArray4(width, height, fill) {
        var a = new RectArray(width, height, 4);
        fillArrayView(a, width, height, 4, fill);
        return a;
      };
    // Nat Nat (Nat Nat Nat -> X) -> RectArray<X,1>
    RectArray.buildN =
      function buildRectArrayN(width, height, n, fill) {
        var a = new RectArray(width, height, n);
        fillArrayView(a, width, height, n, fill);
        return a;
      };
    // Nat Nat (Nat Nat [Nat] -> Byte) -> RectTypedByteArray<4>
    RectByteTypedArray.build =
      function buildRectByteTypedArray1(width, height, fill) {
        var buf = new RectByteTypedArray(width, height, 1);
        fillArrayView(new Uint8Array(buf), width, height, 1, fill);
        return buf;
      };
    // Nat Nat (Nat Nat Nat -> Byte) -> RectTypedByteArray<4>
    RectByteTypedArray.build4 =
      function buildRectByteTypedArray4(width, height, fill) {
        var buf = new RectByteTypedArray(width, height, 4);
        fillArrayView(new Uint8Array(buf), width, height, 4, fill);
        return buf;
      };
    // Nat Nat (Nat Nat Nat -> Byte) -> RectTypedByteArray<4>
    RectByteTypedArray.buildN =
      function buildRectByteTypedArray4(width, height, n, fill) {
        var buf = new RectByteTypedArray(width, height, n);
        fillArrayView(new Uint8Array(buf), width, height, n, fill);
        return buf;
      };
    WrapArray.build =
      function buildWrapArray1(width, height, fill) {
        var a = new WrapArray(width, height, 1);
        fillArrayView(a, width, height, 1, fill);
        return a;
      };
    WrapArray.build =
      function buildWrapArray1(width, height, fill) {
        var a = new WrapArray(width, height, 1);
        fillArrayView(a.backingArray, width, height, 1, fill);
        return a;
      };
    WrapArray.build4 =
      function buildWrapArray1(width, height, fill) {
        var a = new WrapArray(width, height, 4);
        fillArrayView(a.backingArray, width, height, 4, fill);
        return a;
      };
    WrapArray.buildN =
      function buildWrapArray1(width, height, n, fill) {
        var a = new WrapArray(width, height, n);
        fillArrayView(a.backingArray, width, height, n, fill);
        return a;
      };
  })();