The Tor Browser: comparison js/src/parjs-benchmarks/rectarray.js

comparison: js/src/parjs-benchmarks/rectarray.js

js/src/parjs-benchmarks/rectarray.js

branch: TOR_BUG_9701
changeset 9: a63d609f5ebe

equal deleted inserted replaced

--1:000000000000
+:9fa83f3f7bc3
+// -*- 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;
+};
+})();