Support offset-TypedArray in futex API

test/mjsunit/harmony/futex.js

 // Copyright 2015 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: --allow-natives-syntax --harmony-sharedarraybuffer
 
 (function TestFailsWithNonSharedArray() {
   var ab = new ArrayBuffer(16);
 
   var i8a = new Int8Array(ab);
@@ skipping 28 matching lines @@
 
   [i8a, i16a, ui8a, ui8ca, ui16a, ui32a, f32a, f64a].forEach(function(
       ta) {
     assertThrows(function() { Atomics.futexWait(ta, 0, 0); });
     assertThrows(function() { Atomics.futexWake(ta, 0, 1); });
     assertThrows(function() { Atomics.futexWakeOrRequeue(ta, 0, 1, 0, 0); });
   });
 })();
 
 (function TestInvalidIndex() {
-  var i32a = new Int32Array(new SharedArrayBuffer(16));
+  var sab = new SharedArrayBuffer(16);
+  var i32a = new Int32Array(sab);
 
   // Valid indexes are 0-3.
   [-1, 4, 100].forEach(function(invalidIndex) {
     assertEquals(undefined, Atomics.futexWait(i32a, invalidIndex, 0));
     assertEquals(undefined, Atomics.futexWake(i32a, invalidIndex, 0));
     var validIndex = 0;
     assertEquals(undefined, Atomics.futexWakeOrRequeue(i32a, invalidIndex, 0, 0,
                                                        validIndex));
     assertEquals(undefined, Atomics.futexWakeOrRequeue(i32a, validIndex, 0, 0,
                                                        invalidIndex));
   });
 
+  i32a = new Int32Array(sab, 8);
+  [-1, 2, 100].forEach(function(invalidIndex) {
+    assertEquals(undefined, Atomics.futexWait(i32a, invalidIndex, 0));
+    assertEquals(undefined, Atomics.futexWake(i32a, invalidIndex, 0));
+    var validIndex = 0;
+    assertEquals(undefined, Atomics.futexWakeOrRequeue(i32a, invalidIndex, 0, 0,
+                                                       validIndex));
+    assertEquals(undefined, Atomics.futexWakeOrRequeue(i32a, validIndex, 0, 0,
+                                                       invalidIndex));
+  });
 })();
 
 (function TestWaitTimeout() {
   var i32a = new Int32Array(new SharedArrayBuffer(16));
   var waitMs = 100;
   var startTime = new Date();
   assertEquals(Atomics.TIMEDOUT, Atomics.futexWait(i32a, 0, 0, waitMs));
   var endTime = new Date();
   assertTrue(endTime - startTime >= waitMs);
 })();
 
 (function TestWaitNotEqual() {
-  var i32a = new Int32Array(new SharedArrayBuffer(16));
+  var sab = new SharedArrayBuffer(16);
+  var i32a = new Int32Array(sab);
   assertEquals(Atomics.NOTEQUAL, Atomics.futexWait(i32a, 0, 42));
+
+  i32a = new Int32Array(sab, 8);
+  i32a[0] = 1;
+  assertEquals(Atomics.NOTEQUAL, Atomics.futexWait(i32a, 0, 0));
 })();
 
 (function TestWaitNegativeTimeout() {
   var i32a = new Int32Array(new SharedArrayBuffer(16));
   assertEquals(Atomics.TIMEDOUT, Atomics.futexWait(i32a, 0, 0, -1));
   assertEquals(Atomics.TIMEDOUT, Atomics.futexWait(i32a, 0, 0, -Infinity));
 })();
 
 //// WORKER ONLY TESTS
 
 if (this.Worker) {
 
   var TestWaitWithTimeout = function(timeout) {
     var sab = new SharedArrayBuffer(16);
     var i32a = new Int32Array(sab);
 
     var workerScript =
-      `onmessage = function(sab) {
-         var i32a = new Int32Array(sab);
+      `onmessage = function(msg) {
+         var i32a = new Int32Array(msg.sab, msg.offset);
          var result = Atomics.futexWait(i32a, 0, 0, ${timeout});
          postMessage(result);
        };`;
 
     var worker = new Worker(workerScript);
-    worker.postMessage(sab, [sab]);
+    worker.postMessage({sab: sab, offset: offset}, [sab]);
 
     // Spin until the worker is waiting on the futex.
     while (%AtomicsFutexNumWaitersForTesting(i32a, 0) != 1) {}
 
     Atomics.futexWake(i32a, 0, 1);
     assertEquals(Atomics.OK, worker.getMessage());
     worker.terminate();
+
+    var worker2 = new Worker(workerScript);
+    var offset = 8;
+    var i32a2 = new Int32Array(sab, offset);
+    worker2.postMessage({sab: sab, offset: offset}, [sab]);
+
+    // Spin until the worker is waiting on the futex.
+    while (%AtomicsFutexNumWaitersForTesting(i32a2, 0) != 1) {}
+    Atomics.futexWake(i32a2, 0, 1);
+    assertEquals(Atomics.OK, worker2.getMessage());
+    worker2.terminate();
+
+    // Futex should work when index and buffer views are different, but
+    // the real address is the same.
+    var worker3 = new Worker(workerScript);
+    i32a2 = new Int32Array(sab, 4);
+    worker3.postMessage({sab: sab, offset: 8}, [sab]);
+
+    // Spin until the worker is waiting on the futex.
+    while (%AtomicsFutexNumWaitersForTesting(i32a2, 1) != 1) {}
+    Atomics.futexWake(i32a2, 1, 1);
+    assertEquals(Atomics.OK, worker3.getMessage());
+    worker3.terminate();
   };
 
   // Test various infinite timeouts
   TestWaitWithTimeout(undefined);
   TestWaitWithTimeout(NaN);
   TestWaitWithTimeout(Infinity);
 
 
   (function TestWakeMulti() {
     var sab = new SharedArrayBuffer(20);
@@ skipping 141 matching lines @@
           wokenCount++;
         }
       }
     }
 
     assertEquals(0, %AtomicsFutexNumWaitersForTesting(i32a, index1));
     assertEquals(0, %AtomicsFutexNumWaitersForTesting(i32a, index2));
 
     for (id = 0; id < 4; ++id) {
       assertEquals(Atomics.OK, workers[id].getMessage());
+    }
+
+    // Test futexWakeOrRequeue on offset typed array
+    var offset = 16;
+    sab = new SharedArrayBuffer(24);
+    i32a = new Int32Array(sab);
+    var i32a2 = new Int32Array(sab, offset);
+
+    for (id = 0; id < 4; id++) {
+      workers[id].postMessage({sab: sab, id: id}, [sab]);
+    }
+
+    while (%AtomicsFutexNumWaitersForTesting(i32a2, 0) != 4) { }
+
+    index1 = 0;
+    index2 = 1;
+    assertEquals(4, %AtomicsFutexNumWaitersForTesting(i32a2, index1));
+    assertEquals(0, %AtomicsFutexNumWaitersForTesting(i32a2, index2));
+
+    assertEquals(2, Atomics.futexWakeOrRequeue(i32a2, index1, 2, 0, index2));
+    assertEquals(2, %AtomicsFutexNumWaitersForTesting(i32a2, index2));
+    assertEquals(0, %AtomicsFutexNumWaitersForTesting(i32a2, index1));
+
+    assertEquals(2, Atomics.futexWake(i32a2, index2, 2));
+
+    for (id = 0; id < 4; ++id) {
+      assertEquals(Atomics.OK, workers[id].getMessage());
       workers[id].terminate();
     }
 
   })();
 
 }