SharedArrayBuffer and Atomics tests

INTERPRETING.md

@@ -60,6 +60,33 @@ properties of the global scope prior to test execution.
 
   - **`global`** - a reference to the global object on which `$` was initially
     defined
+  - **`agent`** - an ordinary object with the following properties:
+    - **`start`** - a function that takes a script source string and runs
+      the script in a concurrent agent.  Will block until that agent is
+      running.  The agent has no representation.  The agent script will be
+      run in an environment that has an object `$` with a property `agent`
+      with the following properties:
+      - **`receiveBroadcast`** - a function that takes a function and 
+        calls the function when it has received a broadcast from the parent,
+        passing it the broadcast as two arguments, a SharedArrayBuffer and
+        an Int32.  This function may return before a broadcast is received
+        (eg to return to an event loop to await a message) and no code should
+        follow the call to this function.
+      - **`report`** - a function that takes a string and places it in a
+        transmit queue whence the parent will retrieve it.  Messages
+        should be short.
+      - **`sleep`** - a function that takes a millisecond argument and
+        sleeps the agent for approximately that duration.
+      - **`leaving`** - a function that signals that the agent is done and
+        may be terminated (if possible).
+    - **`broadcast`** - a function that takes a SharedArrayBuffer and an Int32
+        and broadcasts the two values to all concurrent agents.  The function
+        blocks until all agents have retrieved the message.  Note, this assumes
+        that all agents that were started are still running.
+    - **`getReport`** - a function that reads an incoming string from any agent,
+      and returns it if it exists, or returns `null` otherwise.
+    - **`sleep`** - a function that takes a millisecond argument and
+        sleeps the execution for approximately that duration.
 
 ### Strict Mode
 

harness/agent_spidermonkey.js

@@ -0,0 +1,123 @@
+// Copyright (C) 2015 Mozilla Corporation.  All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+//
+// An implementation of '$.agent' for the SpiderMonkey shell.
+// See ../INTERPRETING.md for the API definition.
+
+if (typeof $ == 'undefined')
+    $ = {};
+
+$.agent = (function () {
+
+// The SpiderMonkey implementation uses a designated shared buffer _ia
+// for coordination, and spinlocks for everything except sleeping.
+
+var _MSG_LOC = 0;               // Low bit set: broadcast available; High bits: seq #
+var _ID_LOC = 1;                // ID sent with broadcast
+var _ACK_LOC = 2;               // Worker increments this to ack that broadcast was received
+var _RDY_LOC = 3;               // Worker increments this to ack that worker is up and running
+var _LOCKTXT_LOC = 4;           // Writer lock for the text buffer: 0=open, 1=closed
+var _NUMTXT_LOC = 5;            // Count of messages in text buffer
+var _NEXT_LOC = 6;              // First free location in the buffer
+var _SLEEP_LOC = 7;             // Used for sleeping
+
+var _FIRST = 10;                // First location of first message
+
+var _ia = new Int32Array(new SharedArrayBuffer(65536));
+_ia[_NEXT_LOC] = _FIRST;
+
+var _worker_prefix = `
+if (typeof $ == 'undefined')
+    $ = {};
+
+$.agent = (function () {
+
+var _ia;
+
+var agent = {
+    _ia: null,
+
+    receiveBroadcast: function(receiver) {
+        var k;
+        while (((k = Atomics.load(_ia, ${_MSG_LOC})) & 1) == 0)
+            ;
+        var received_sab = getSharedArrayBuffer();
+        var received_id = Atomics.load(_ia, ${_ID_LOC});
+        Atomics.add(_ia, ${_ACK_LOC}, 1);
+        while (Atomics.load(_ia, ${_MSG_LOC}) == k)
+            ;
+        receiver(received_sab, received_id);
+    },
+
+    report: function(msg) {
+        while (Atomics.compareExchange(_ia, ${_LOCKTXT_LOC}, 0, 1) == 1)
+            ;
+        msg = "" + msg;
+        var i = _ia[${_NEXT_LOC}];
+        _ia[i++] = msg.length;
+        for ( let j=0 ; j < msg.length ; j++ )
+            _ia[i++] = msg.charCodeAt(j);
+        _ia[${_NEXT_LOC}] = i;
+        Atomics.add(_ia, ${_NUMTXT_LOC}, 1);
+        Atomics.store(_ia, ${_LOCKTXT_LOC}, 0);
+    },
+
+    sleep: function(s) {
+        Atomics.wait(_ia, ${_SLEEP_LOC}, 0, s);
+    },
+
+    leaving: function() {}
+};
+
+_ia = new Int32Array(getSharedArrayBuffer());
+Atomics.add(_ia, ${_RDY_LOC}, 1);
+
+return agent;
+})();
+`;
+
+var agent =
+{
+    _numWorkers: 0,
+    _numReports: 0,
+    _reportPtr: _FIRST,
+
+    start: function (script) {
+        setSharedArrayBuffer(_ia.buffer);
+        var oldrdy = Atomics.load(_ia, _RDY_LOC);
+        evalInWorker(_worker_prefix + script);
+        while (Atomics.load(_ia, _RDY_LOC) == oldrdy)
+            ;
+        this._numWorkers++;
+    },
+
+    broadcast: function (sab, id) {
+        setSharedArrayBuffer(sab);
+        Atomics.store(_ia, _ID_LOC, id);
+        Atomics.store(_ia, _ACK_LOC, 0);
+        Atomics.add(_ia, _MSG_LOC, 1);
+        while (Atomics.load(_ia, _ACK_LOC) < this._numWorkers)
+            ;
+        Atomics.add(_ia, _MSG_LOC, 1);
+    },
+
+    getReport: function () {
+        if (this._numReports == Atomics.load(_ia, _NUMTXT_LOC))
+            return null;
+        var s = "";
+        var i = this._reportPtr;
+        var len = _ia[i++];
+        for ( let j=0 ; j < len ; j++ )
+            s += String.fromCharCode(_ia[i++]);
+        this._reportPtr = i;
+        this._numReports++;
+        return s;
+    },
+
+    sleep: function(s) {
+        Atomics.wait(_ia, _SLEEP_LOC, 0, s);
+    },
+}
+
+return agent;
+})();

test/built-ins/Atomics/Symbol.toStringTag.js

@@ -0,0 +1,20 @@
+// Copyright (C) 2017 Mozilla Corporation.  All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+/*---
+description: >
+    `Symbol.toStringTag` property descriptor on Atomics
+info: >
+    The initial value of the @@toStringTag property is the String value
+    "Atomics".
+
+    This property has the attributes { [[Writable]]: false, [[Enumerable]]:
+    false, [[Configurable]]: true }.
+includes: [propertyHelper.js]
+features: [Symbol.toStringTag]
+---*/
+
+assert.sameValue(Atomics[Symbol.toStringTag], 'Atomics');
+
+verifyNotEnumerable(Atomics, Symbol.toStringTag);
+verifyNotWritable(Atomics, Symbol.toStringTag);
+verifyConfigurable(Atomics, Symbol.toStringTag);

test/built-ins/Atomics/add/bad-range.js

@@ -0,0 +1,33 @@
+// Copyright (C) 2015 Mozilla Corporation.  All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+
+/*---
+description: >
+  Test range checking of Atomics.add on arrays that allow atomic operations
+---*/
+
+var sab = new SharedArrayBuffer(4);
+
+var views = [Int8Array, Uint8Array, Int16Array, Uint16Array, Int32Array, Uint32Array];
+
+var bad_indices = [ (view) => -1,
+                    (view) => view.length,
+                    (view) => view.length*2,
+                    (view) => undefined,
+                    (view) => Number.NaN,
+                    (view) => Number.POSITIVE_INFINITY,
+                    (view) => Number.NEGATIVE_INFINITY,
+                    (view) => '3.5',
+                    (view) => 3.5,
+                    (view) => { password: "qumquat" },
+                    (view) => ({ valueOf: () => 125 }),
+                    (view) => ({ toString: () => '125', valueOf: false }) // non-callable valueOf triggers invocation of toString
+                  ];
+
+for ( let View of views ) {
+    let view = new View(sab);
+    for ( let IdxGen of bad_indices ) {
+        var Idx = IdxGen(view);
+        assert.throws(RangeError, () => Atomics.add(view, Idx, 10));
+    }
+}

test/built-ins/Atomics/add/descriptor.js

@@ -0,0 +1,11 @@
+// Copyright 2015 Microsoft Corporation. All rights reserved.
+// This code is governed by the license found in the LICENSE file.
+
+/*---
+description: Testing descriptor property of Atomics.add
+includes: [propertyHelper.js]
+---*/
+
+verifyWritable(Atomics, "add");
+verifyNotEnumerable(Atomics, "add");
+verifyConfigurable(Atomics, "add");

test/built-ins/Atomics/add/good-views.js

@@ -0,0 +1,59 @@
+// Copyright (C) 2016 Mozilla Corporation.  All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+
+/*---
+description: Test Atomics.add on arrays that allow atomic operations.
+---*/
+
+var sab = new SharedArrayBuffer(1024);
+var ab = new ArrayBuffer(16);
+
+var int_views = [Int8Array, Uint8Array, Int16Array, Uint16Array, Int32Array, Uint32Array];
+
+var good_indices = [ (view) => 0/-1, // -0
+                     (view) => '-0',
+                     (view) => view.length - 1,
+                     (view) => ({ valueOf: () => 0 }),
+                     (view) => ({ toString: () => '0', valueOf: false }) // non-callable valueOf triggers invocation of toString
+                   ];
+
+for ( let View of int_views ) {
+    // Make it interesting - use non-zero byteOffsets and non-zero indexes.
+
+    var view = new View(sab, 32, 20);
+    var control = new View(ab, 0, 2);
+
+    // Add positive number
+    view[8] = 0;
+    assert.sameValue(Atomics.add(view, 8, 10), 0);
+    assert.sameValue(view[8], 10);
+
+    // Add negative number
+    assert.sameValue(Atomics.add(view, 8, -5), 10);
+    assert.sameValue(view[8], 5);
+
+    // Result is "negative" though subject to coercion
+    view[3] = -5;
+    control[0] = -5;
+    assert.sameValue(Atomics.add(view, 3, 0), control[0]);
+
+    // Result is subject to chopping
+    control[0] = 12345;
+    view[3] = 12345;
+    assert.sameValue(Atomics.add(view, 3, 0), control[0]);
+
+    // And again
+    control[0] = 123456789;
+    view[3] = 123456789;
+    assert.sameValue(Atomics.add(view, 3, 0), control[0]);
+
+    // In-bounds boundary cases for indexing
+    for ( let IdxGen of good_indices ) {
+        let Idx = IdxGen(view);
+        view.fill(0);
+        // Atomics.store() computes an index from Idx in the same way as other
+        // Atomics operations, not quite like view[Idx].
+        Atomics.store(view, Idx, 37);
+        assert.sameValue(Atomics.add(view, Idx, 0), 37);
+    }
+}

test/built-ins/Atomics/add/length.js

@@ -0,0 +1,28 @@
+// Copyright (C) 2015 André Bargull. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+
+/*---
+description: >
+  Atomics.add.length is 3.
+info: >
+  Atomics.add ( ia, index, val )
+
+  17 ECMAScript Standard Built-in Objects:
+    Every built-in Function object, including constructors, has a length
+    property whose value is an integer. Unless otherwise specified, this
+    value is equal to the largest number of named arguments shown in the
+    subclause headings for the function description, including optional
+    parameters. However, rest parameters shown using the form “...name”
+    are not included in the default argument count.
+
+    Unless otherwise specified, the length property of a built-in Function
+    object has the attributes { [[Writable]]: false, [[Enumerable]]: false,
+    [[Configurable]]: true }.
+includes: [propertyHelper.js]
+---*/
+
+assert.sameValue(Atomics.add.length, 3);
+
+verifyNotEnumerable(Atomics.add, "length");
+verifyNotWritable(Atomics.add, "length");
+verifyConfigurable(Atomics.add, "length");

test/built-ins/Atomics/add/name.js

@@ -0,0 +1,14 @@
+// Copyright (C) 2015 André Bargull. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+
+/*---
+description: >
+  Atomics.add.name is "add".
+includes: [propertyHelper.js]
+---*/
+
+assert.sameValue(Atomics.add.name, "add");
+
+verifyNotEnumerable(Atomics.add, "name");
+verifyNotWritable(Atomics.add, "name");
+verifyConfigurable(Atomics.add, "name");

test/built-ins/Atomics/add/non-views.js

@@ -0,0 +1,42 @@
+// Copyright (C) 2015 Mozilla Corporation.  All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+
+/*---
+description: >
+  Test Atomics.add on view values other than TypedArrays
+---*/
+
+var values = [null,
+              undefined,
+              true,
+              false,
+              new Boolean(true),
+              10,
+              3.14,
+              new Number(4),
+              "Hi there",
+              new Date,
+              /a*utomaton/g,
+              { password: "qumquat" },
+              new DataView(new ArrayBuffer(10)),
+              new ArrayBuffer(128),
+              new SharedArrayBuffer(128),
+              new Error("Ouch"),
+              [1,1,2,3,5,8],
+              ((x) => -x),
+              new Map(),
+              new Set(),
+              new WeakMap(),
+              new WeakSet(),
+              this.Promise ? new Promise(() => "done") : undefined,
+              Symbol("halleluja"),
+              // TODO: Proxy?
+              Object,
+              Int32Array,
+              Date,
+              Math,
+              Atomics ];
+
+for ( var view of values ) {
+    assert.throws(TypeError, (() => Atomics.add(view, 0, 0)));
+}

test/built-ins/Atomics/add/nonshared-int-views.js

@@ -0,0 +1,17 @@
+// Copyright (C) 2015 Mozilla Corporation.  All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+
+/*---
+description: >
+  Test Atomics.add on non-shared integer TypedArrays
+---*/
+
+var ab = new ArrayBuffer(16);
+
+var int_views = [Int8Array, Uint8Array, Int16Array, Uint16Array, Int32Array, Uint32Array];
+
+for ( var View of int_views ) {
+    var view = new View(ab);
+
+    assert.throws(TypeError, (() => Atomics.add(view, 0, 0)));
+}