Support SAB atomics for offset-TypedArray

test/mjsunit/harmony/atomics.js

 // Copyright 2014 the V8 project authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 // Flags: --harmony-sharedarraybuffer
 //
 
 function toRangeWrapped(value) {
   var range = this.max - this.min + 1;
   while (value < this.min) {
@@ skipping 59 matching lines @@
 
   for (var i = 0; i < ia.length; ++i) {
     if (i == expectedIndex) continue;
     assertEquals(22, ia[i], name);
   }
 }
 
 (function TestBadIndex() {
   var sab = new SharedArrayBuffer(8);
   var si32a = new Int32Array(sab);
+  var si32a2 = new Int32Array(sab, 4);
 
   // Non-integer indexes are converted to an integer first, so they should all
   // operate on index 0.
   [undefined, null, false, 'hi', {}].forEach(function(i) {
+
     var name = String(i);
-
     testAtomicOp(Atomics.compareExchange, si32a, i, 0, name);
     testAtomicOp(Atomics.load, si32a, i, 0, name);
     testAtomicOp(Atomics.store, si32a, i, 0, name);
     testAtomicOp(Atomics.add, si32a, i, 0, name);
     testAtomicOp(Atomics.sub, si32a, i, 0, name);
     testAtomicOp(Atomics.and, si32a, i, 0, name);
     testAtomicOp(Atomics.or, si32a, i, 0, name);
     testAtomicOp(Atomics.xor, si32a, i, 0, name);
     testAtomicOp(Atomics.exchange, si32a, i, 0, name);
   });
 
   // Out-of-bounds indexes should return undefined.
   // TODO(binji): Should these throw RangeError instead?
   [-1, 2, 100].forEach(function(i) {
     var name = String(i);
     assertEquals(undefined, Atomics.compareExchange(si32a, i, 0, 0), name);
     assertEquals(undefined, Atomics.load(si32a, i), name);
     assertEquals(undefined, Atomics.store(si32a, i, 0), name);
     assertEquals(undefined, Atomics.add(si32a, i, 0), name);
     assertEquals(undefined, Atomics.sub(si32a, i, 0), name);
     assertEquals(undefined, Atomics.and(si32a, i, 0), name);
     assertEquals(undefined, Atomics.or(si32a, i, 0), name);
     assertEquals(undefined, Atomics.xor(si32a, i, 0), name);
     assertEquals(undefined, Atomics.exchange(si32a, i, 0), name);
   });
 
+  // Out-of-bounds indexes for offset-array
+  [-1, 1, 100].forEach(function(i) {
+    var name = String(i);
+    assertEquals(undefined, Atomics.compareExchange(si32a2, i, 0, 0), name);
+    assertEquals(undefined, Atomics.load(si32a2, i), name);
+    assertEquals(undefined, Atomics.store(si32a2, i, 0), name);
+    assertEquals(undefined, Atomics.add(si32a2, i, 0), name);
+    assertEquals(undefined, Atomics.sub(si32a2, i, 0), name);
+    assertEquals(undefined, Atomics.and(si32a2, i, 0), name);
+    assertEquals(undefined, Atomics.or(si32a2, i, 0), name);
+    assertEquals(undefined, Atomics.xor(si32a2, i, 0), name);
+    assertEquals(undefined, Atomics.exchange(si32a2, i, 0), name);
+  });
+
   // Monkey-patch length and make sure these functions still return undefined.
   Object.defineProperty(si32a, 'length', {get: function() { return 1000; }});
   [2, 100].forEach(function(i) {
     var name = String(i);
     assertEquals(undefined, Atomics.compareExchange(si32a, i, 0, 0), name);
     assertEquals(undefined, Atomics.load(si32a, i), name);
     assertEquals(undefined, Atomics.store(si32a, i, 0), name);
     assertEquals(undefined, Atomics.add(si32a, i, 0), name);
     assertEquals(undefined, Atomics.sub(si32a, i, 0), name);
     assertEquals(undefined, Atomics.and(si32a, i, 0), name);
     assertEquals(undefined, Atomics.or(si32a, i, 0), name);
     assertEquals(undefined, Atomics.xor(si32a, i, 0), name);
     assertEquals(undefined, Atomics.exchange(si32a, i, 0), name);
   });
 })();
 
 (function TestGoodIndex() {
   var sab = new SharedArrayBuffer(64);
   var si32a = new Int32Array(sab);
+  var si32a2 = new Int32Array(sab, 32);
 
   var valueOf = {valueOf: function(){ return 3;}};
   var toString = {toString: function(){ return '3';}};
 
   [3, 3.5, '3', '3.5', valueOf, toString].forEach(function(i) {
     var name = String(i);
-
-    testAtomicOp(Atomics.compareExchange, si32a, i, 3, name);
-    testAtomicOp(Atomics.load, si32a, i, 3, name);
-    testAtomicOp(Atomics.store, si32a, i, 3, name);
-    testAtomicOp(Atomics.add, si32a, i, 3, name);
-    testAtomicOp(Atomics.sub, si32a, i, 3, name);
-    testAtomicOp(Atomics.and, si32a, i, 3, name);
-    testAtomicOp(Atomics.or, si32a, i, 3, name);
-    testAtomicOp(Atomics.xor, si32a, i, 3, name);
-    testAtomicOp(Atomics.exchange, si32a, i, 3, name);
+    [si32a, si32a2].forEach(function(array) {
+        testAtomicOp(Atomics.compareExchange, array, i, 3, name);
+        testAtomicOp(Atomics.load, array, i, 3, name);
+        testAtomicOp(Atomics.store, array, i, 3, name);
+        testAtomicOp(Atomics.add, array, i, 3, name);
+        testAtomicOp(Atomics.sub, array, i, 3, name);
+        testAtomicOp(Atomics.and, array, i, 3, name);
+        testAtomicOp(Atomics.or, array, i, 3, name);
+        testAtomicOp(Atomics.xor, array, i, 3, name);
+        testAtomicOp(Atomics.exchange, array, i, 3, name);
+      })
   });
 })();
 
+function clearArray(sab) {
+  var ui8 = new Uint8Array(sab);
+  for (var i = 0; i < sab.byteLength; ++i) {
+    ui8[i] = 0;
+  }
+}
+
 (function TestCompareExchange() {
   IntegerTypedArrayConstructors.forEach(function(t) {
     var sab = new SharedArrayBuffer(10 * t.constr.BYTES_PER_ELEMENT);
     var sta = new t.constr(sab);
-    var name = Object.prototype.toString.call(sta);
-    for (var i = 0; i < 10; ++i) {
-      // sta[i] == 0, CAS will store
-      assertEquals(0, Atomics.compareExchange(sta, i, 0, 50), name);
-      assertEquals(50, sta[i], name);
+    var sta2 = new t.constr(sab, 5 * t.constr.BYTES_PER_ELEMENT);
 
-      // sta[i] == 50, CAS will not store
-      assertEquals(50, Atomics.compareExchange(sta, i, 0, 100), name);
-      assertEquals(50, sta[i], name);
-    }
+    [sta, sta2].forEach(function(array) {
+      clearArray(array.buffer);
+      var name = Object.prototype.toString.call(array);
+      for (var i = 0; i < array.length; ++i) {
+        // array[i] == 0, CAS will store
+        assertEquals(0, Atomics.compareExchange(array, i, 0, 50), name);
+        assertEquals(50, array[i], name);
+
+        // array[i] == 50, CAS will not store
+        assertEquals(50, Atomics.compareExchange(array, i, 0, 100), name);
+        assertEquals(50, array[i], name);
+      }
+    })
   });
 })();
 
 (function TestLoad() {
   IntegerTypedArrayConstructors.forEach(function(t) {
     var sab = new SharedArrayBuffer(10 * t.constr.BYTES_PER_ELEMENT);
     var sta = new t.constr(sab);
-    var name = Object.prototype.toString.call(sta);
-    for (var i = 0; i < 10; ++i) {
-      sta[i] = 0;
-      assertEquals(0, Atomics.load(sta, i), name);
-      sta[i] = 50;
-      assertEquals(50, Atomics.load(sta, i), name);
-    }
+    var sta2 = new t.constr(sab, 5 * t.constr.BYTES_PER_ELEMENT);
+
+    [sta, sta2].forEach(function(array) {
+      clearArray(array.buffer);
+      var name = Object.prototype.toString.call(array);
+      for (var i = 0; i < array.length; ++i) {
+        array[i] = 0;
+        assertEquals(0, Atomics.load(array, i), name);
+        array[i] = 50;
+        assertEquals(50, Atomics.load(array, i), name);
+      }
+    })
   });
 })();
 
 (function TestStore() {
   IntegerTypedArrayConstructors.forEach(function(t) {
     var sab = new SharedArrayBuffer(10 * t.constr.BYTES_PER_ELEMENT);
     var sta = new t.constr(sab);
-    var name = Object.prototype.toString.call(sta);
-    for (var i = 0; i < 10; ++i) {
-      assertEquals(50, Atomics.store(sta, i, 50), name);
-      assertEquals(50, sta[i], name);
+    var sta2 = new t.constr(sab, 5 * t.constr.BYTES_PER_ELEMENT);
 
-      assertEquals(100, Atomics.store(sta, i, 100), name);
-      assertEquals(100, sta[i], name);
-    }
+    [sta, sta2].forEach(function(array) {
+      clearArray(array.buffer);
+      var name = Object.prototype.toString.call(array);
+      for (var i = 0; i < array.length; ++i) {
+        assertEquals(50, Atomics.store(array, i, 50), name);
+        assertEquals(50, array[i], name);
+
+        assertEquals(100, Atomics.store(array, i, 100), name);
+        assertEquals(100, array[i], name);
+      }
+    })
   });
 })();
 
 (function TestAdd() {
   IntegerTypedArrayConstructors.forEach(function(t) {
     var sab = new SharedArrayBuffer(10 * t.constr.BYTES_PER_ELEMENT);
     var sta = new t.constr(sab);
-    var name = Object.prototype.toString.call(sta);
-    for (var i = 0; i < 10; ++i) {
-      assertEquals(0, Atomics.add(sta, i, 50), name);
-      assertEquals(50, sta[i], name);
+    var sta2 = new t.constr(sab, 5 * t.constr.BYTES_PER_ELEMENT);
 
-      assertEquals(50, Atomics.add(sta, i, 70), name);
-      assertEquals(120, sta[i], name);
-    }
+    [sta, sta2].forEach(function(array) {
+      clearArray(array.buffer);
+      var name = Object.prototype.toString.call(array);
+      for (var i = 0; i < array.length; ++i) {
+        assertEquals(0, Atomics.add(array, i, 50), name);
+        assertEquals(50, array[i], name);
+
+        assertEquals(50, Atomics.add(array, i, 70), name);
+        assertEquals(120, array[i], name);
+      }
+    })
   });
 })();
 
 (function TestSub() {
   IntegerTypedArrayConstructors.forEach(function(t) {
     var sab = new SharedArrayBuffer(10 * t.constr.BYTES_PER_ELEMENT);
     var sta = new t.constr(sab);
-    var name = Object.prototype.toString.call(sta);
-    for (var i = 0; i < 10; ++i) {
-      sta[i] = 120;
-      assertEquals(120, Atomics.sub(sta, i, 50), name);
-      assertEquals(70, sta[i], name);
+    var sta2 = new t.constr(sab, 5 * t.constr.BYTES_PER_ELEMENT);
 
-      assertEquals(70, Atomics.sub(sta, i, 70), name);
-      assertEquals(0, sta[i], name);
-    }
+    [sta, sta2].forEach(function(array) {
+      clearArray(array.buffer);
+      var name = Object.prototype.toString.call(array);
+      for (var i = 0; i < array.length; ++i) {
+        array[i] = 120;
+        assertEquals(120, Atomics.sub(array, i, 50), name);
+        assertEquals(70, array[i], name);
+
+        assertEquals(70, Atomics.sub(array, i, 70), name);
+        assertEquals(0, array[i], name);
+      }
+    })
   });
 })();
 
 (function TestAnd() {
   IntegerTypedArrayConstructors.forEach(function(t) {
     var sab = new SharedArrayBuffer(10 * t.constr.BYTES_PER_ELEMENT);
     var sta = new t.constr(sab);
-    var name = Object.prototype.toString.call(sta);
-    for (var i = 0; i < 10; ++i) {
-      sta[i] = 0x3f;
-      assertEquals(0x3f, Atomics.and(sta, i, 0x30), name);
-      assertEquals(0x30, sta[i], name);
+    var sta2 = new t.constr(sab, 5 * t.constr.BYTES_PER_ELEMENT);
 
-      assertEquals(0x30, Atomics.and(sta, i, 0x20), name);
-      assertEquals(0x20, sta[i], name);
-    }
+    [sta, sta2].forEach(function(array) {
+      clearArray(array.buffer);
+      var name = Object.prototype.toString.call(sta);
+      for (var i = 0; i < array.length; ++i) {
+        array[i] = 0x3f;
+        assertEquals(0x3f, Atomics.and(array, i, 0x30), name);
+        assertEquals(0x30, array[i], name);
+
+        assertEquals(0x30, Atomics.and(array, i, 0x20), name);
+        assertEquals(0x20, array[i], name);
+      }
+    })
   });
 })();
 
 (function TestOr() {
   IntegerTypedArrayConstructors.forEach(function(t) {
     var sab = new SharedArrayBuffer(10 * t.constr.BYTES_PER_ELEMENT);
     var sta = new t.constr(sab);
-    var name = Object.prototype.toString.call(sta);
-    for (var i = 0; i < 10; ++i) {
-      sta[i] = 0x30;
-      assertEquals(0x30, Atomics.or(sta, i, 0x1c), name);
-      assertEquals(0x3c, sta[i], name);
+    var sta2 = new t.constr(sab, 5 * t.constr.BYTES_PER_ELEMENT);
 
-      assertEquals(0x3c, Atomics.or(sta, i, 0x09), name);
-      assertEquals(0x3d, sta[i], name);
-    }
+    [sta, sta2].forEach(function(array) {
+      clearArray(array.buffer);
+      var name = Object.prototype.toString.call(array);
+      for (var i = 0; i < array.length; ++i) {
+        array[i] = 0x30;
+        assertEquals(0x30, Atomics.or(array, i, 0x1c), name);
+        assertEquals(0x3c, array[i], name);
+
+        assertEquals(0x3c, Atomics.or(array, i, 0x09), name);
+        assertEquals(0x3d, array[i], name);
+      }
+    })
   });
 })();
 
 (function TestXor() {
   IntegerTypedArrayConstructors.forEach(function(t) {
     var sab = new SharedArrayBuffer(10 * t.constr.BYTES_PER_ELEMENT);
     var sta = new t.constr(sab);
-    var name = Object.prototype.toString.call(sta);
-    for (var i = 0; i < 10; ++i) {
-      sta[i] = 0x30;
-      assertEquals(0x30, Atomics.xor(sta, i, 0x1c), name);
-      assertEquals(0x2c, sta[i], name);
+    var sta2 = new t.constr(sab, 5 * t.constr.BYTES_PER_ELEMENT);
 
-      assertEquals(0x2c, Atomics.xor(sta, i, 0x09), name);
-      assertEquals(0x25, sta[i], name);
-    }
+    [sta, sta2].forEach(function(array) {
+      clearArray(array.buffer);
+      var name = Object.prototype.toString.call(array);
+      for (var i = 0; i < array.length; ++i) {
+        array[i] = 0x30;
+        assertEquals(0x30, Atomics.xor(array, i, 0x1c), name);
+        assertEquals(0x2c, array[i], name);
+
+        assertEquals(0x2c, Atomics.xor(array, i, 0x09), name);
+        assertEquals(0x25, array[i], name);
+      }
+    })
   });
 })();
 
 (function TestExchange() {
   IntegerTypedArrayConstructors.forEach(function(t) {
     var sab = new SharedArrayBuffer(10 * t.constr.BYTES_PER_ELEMENT);
     var sta = new t.constr(sab);
-    var name = Object.prototype.toString.call(sta);
-    for (var i = 0; i < 10; ++i) {
-      sta[i] = 0x30;
-      assertEquals(0x30, Atomics.exchange(sta, i, 0x1c), name);
-      assertEquals(0x1c, sta[i], name);
+    var sta2 = new t.constr(sab, 5 * t.constr.BYTES_PER_ELEMENT);
 
-      assertEquals(0x1c, Atomics.exchange(sta, i, 0x09), name);
-      assertEquals(0x09, sta[i], name);
-    }
+    [sta, sta2].forEach(function(array) {
+      clearArray(array.buffer);
+      var name = Object.prototype.toString.call(array);
+      for (var i = 0; i < array.length; ++i) {
+        array[i] = 0x30;
+        assertEquals(0x30, Atomics.exchange(array, i, 0x1c), name);
+        assertEquals(0x1c, array[i], name);
+
+        assertEquals(0x1c, Atomics.exchange(array, i, 0x09), name);
+        assertEquals(0x09, array[i], name);
+      }
+    })
   });
 })();
 
 (function TestIsLockFree() {
   // For all platforms we support, 1, 2 and 4 bytes should be lock-free.
   assertEquals(true, Atomics.isLockFree(1));
   assertEquals(true, Atomics.isLockFree(2));
   assertEquals(true, Atomics.isLockFree(4));
 
   // Sizes that aren't equal to a typedarray BYTES_PER_ELEMENT always return
@@ skipping 153 matching lines @@
       // Exchange
       sta[0] = val = 0x12;
       operand = 0x22 + offset;
       valWrapped = t.toRange(operand);
       assertEquals(val, Atomics.exchange(sta, 0, operand), name);
       assertEquals(valWrapped, sta[0], name);
     }
 
   });
 })();