AuroraMiddleware/v8
1
0
Fork 0
Code Issues 2 Pull Requests Releases Wiki Activity

Support SAB atomics for offset-TypedArray

Browse Source 
BUG=497295
LOG=n

Review URL: https://codereview.chromium.org/1422533009

Cr-Commit-Position: refs/heads/master@{#32064}
This commit is contained in:
pan.deng 2015-11-17 16:19:41 -08:00 committed by Commit bot
parent 8e5840e19b
commit 81fe5b3c45
11 changed files with 429 additions and 264 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

63
src/runtime/runtime-atomics.cc
View File

@ -444,18 +444,19 @@ RUNTIME_FUNCTION(Runtime_AtomicsCompareExchange) {
RUNTIME_ASSERT(sta->GetBuffer()->is_shared());
RUNTIME_ASSERT(index < NumberToSize(isolate, sta->length()));
void* buffer = sta->GetBuffer()->backing_store();
uint8_t* source = static_cast<uint8_t*>(sta->GetBuffer()->backing_store()) +
NumberToSize(isolate, sta->byte_offset());
switch (sta->type()) {
#define TYPED_ARRAY_CASE(Type, typeName, TYPE, ctype, size) \
case kExternal##Type##Array: \
return DoCompareExchange<ctype>(isolate, buffer, index, oldobj, newobj);
return DoCompareExchange<ctype>(isolate, source, index, oldobj, newobj);
INTEGER_TYPED_ARRAYS(TYPED_ARRAY_CASE)
#undef TYPED_ARRAY_CASE
case kExternalUint8ClampedArray:
return DoCompareExchangeUint8Clamped(isolate, buffer, index, oldobj,
return DoCompareExchangeUint8Clamped(isolate, source, index, oldobj,
newobj);
default:
@ -475,18 +476,19 @@ RUNTIME_FUNCTION(Runtime_AtomicsLoad) {
RUNTIME_ASSERT(sta->GetBuffer()->is_shared());
RUNTIME_ASSERT(index < NumberToSize(isolate, sta->length()));
void* buffer = sta->GetBuffer()->backing_store();
uint8_t* source = static_cast<uint8_t*>(sta->GetBuffer()->backing_store()) +
NumberToSize(isolate, sta->byte_offset());
switch (sta->type()) {
#define TYPED_ARRAY_CASE(Type, typeName, TYPE, ctype, size) \
case kExternal##Type##Array: \
return DoLoad<ctype>(isolate, buffer, index);
return DoLoad<ctype>(isolate, source, index);
INTEGER_TYPED_ARRAYS(TYPED_ARRAY_CASE)
#undef TYPED_ARRAY_CASE
case kExternalUint8ClampedArray:
return DoLoad<uint8_t>(isolate, buffer, index);
return DoLoad<uint8_t>(isolate, source, index);
default:
break;
@ -506,18 +508,19 @@ RUNTIME_FUNCTION(Runtime_AtomicsStore) {
RUNTIME_ASSERT(sta->GetBuffer()->is_shared());
RUNTIME_ASSERT(index < NumberToSize(isolate, sta->length()));
void* buffer = sta->GetBuffer()->backing_store();
uint8_t* source = static_cast<uint8_t*>(sta->GetBuffer()->backing_store()) +
NumberToSize(isolate, sta->byte_offset());
switch (sta->type()) {
#define TYPED_ARRAY_CASE(Type, typeName, TYPE, ctype, size) \
case kExternal##Type##Array: \
return DoStore<ctype>(isolate, buffer, index, value);
return DoStore<ctype>(isolate, source, index, value);
INTEGER_TYPED_ARRAYS(TYPED_ARRAY_CASE)
#undef TYPED_ARRAY_CASE
case kExternalUint8ClampedArray:
return DoStoreUint8Clamped(isolate, buffer, index, value);
return DoStoreUint8Clamped(isolate, source, index, value);
default:
break;
@ -537,18 +540,19 @@ RUNTIME_FUNCTION(Runtime_AtomicsAdd) {
RUNTIME_ASSERT(sta->GetBuffer()->is_shared());
RUNTIME_ASSERT(index < NumberToSize(isolate, sta->length()));
void* buffer = sta->GetBuffer()->backing_store();
uint8_t* source = static_cast<uint8_t*>(sta->GetBuffer()->backing_store()) +
NumberToSize(isolate, sta->byte_offset());
switch (sta->type()) {
#define TYPED_ARRAY_CASE(Type, typeName, TYPE, ctype, size) \
case kExternal##Type##Array: \
return DoAdd<ctype>(isolate, buffer, index, value);
return DoAdd<ctype>(isolate, source, index, value);
INTEGER_TYPED_ARRAYS(TYPED_ARRAY_CASE)
#undef TYPED_ARRAY_CASE
case kExternalUint8ClampedArray:
return DoAddUint8Clamped(isolate, buffer, index, value);
return DoAddUint8Clamped(isolate, source, index, value);
default:
break;
@ -568,18 +572,19 @@ RUNTIME_FUNCTION(Runtime_AtomicsSub) {
RUNTIME_ASSERT(sta->GetBuffer()->is_shared());
RUNTIME_ASSERT(index < NumberToSize(isolate, sta->length()));
void* buffer = sta->GetBuffer()->backing_store();
uint8_t* source = static_cast<uint8_t*>(sta->GetBuffer()->backing_store()) +
NumberToSize(isolate, sta->byte_offset());
switch (sta->type()) {
#define TYPED_ARRAY_CASE(Type, typeName, TYPE, ctype, size) \
case kExternal##Type##Array: \
return DoSub<ctype>(isolate, buffer, index, value);
return DoSub<ctype>(isolate, source, index, value);
INTEGER_TYPED_ARRAYS(TYPED_ARRAY_CASE)
#undef TYPED_ARRAY_CASE
case kExternalUint8ClampedArray:
return DoSubUint8Clamped(isolate, buffer, index, value);
return DoSubUint8Clamped(isolate, source, index, value);
default:
break;
@ -599,18 +604,19 @@ RUNTIME_FUNCTION(Runtime_AtomicsAnd) {
RUNTIME_ASSERT(sta->GetBuffer()->is_shared());
RUNTIME_ASSERT(index < NumberToSize(isolate, sta->length()));
void* buffer = sta->GetBuffer()->backing_store();
uint8_t* source = static_cast<uint8_t*>(sta->GetBuffer()->backing_store()) +
NumberToSize(isolate, sta->byte_offset());
switch (sta->type()) {
#define TYPED_ARRAY_CASE(Type, typeName, TYPE, ctype, size) \
case kExternal##Type##Array: \
return DoAnd<ctype>(isolate, buffer, index, value);
return DoAnd<ctype>(isolate, source, index, value);
INTEGER_TYPED_ARRAYS(TYPED_ARRAY_CASE)
#undef TYPED_ARRAY_CASE
case kExternalUint8ClampedArray:
return DoAndUint8Clamped(isolate, buffer, index, value);
return DoAndUint8Clamped(isolate, source, index, value);
default:
break;
@ -630,18 +636,19 @@ RUNTIME_FUNCTION(Runtime_AtomicsOr) {
RUNTIME_ASSERT(sta->GetBuffer()->is_shared());
RUNTIME_ASSERT(index < NumberToSize(isolate, sta->length()));
void* buffer = sta->GetBuffer()->backing_store();
uint8_t* source = static_cast<uint8_t*>(sta->GetBuffer()->backing_store()) +
NumberToSize(isolate, sta->byte_offset());
switch (sta->type()) {
#define TYPED_ARRAY_CASE(Type, typeName, TYPE, ctype, size) \
case kExternal##Type##Array: \
return DoOr<ctype>(isolate, buffer, index, value);
return DoOr<ctype>(isolate, source, index, value);
INTEGER_TYPED_ARRAYS(TYPED_ARRAY_CASE)
#undef TYPED_ARRAY_CASE
case kExternalUint8ClampedArray:
return DoOrUint8Clamped(isolate, buffer, index, value);
return DoOrUint8Clamped(isolate, source, index, value);
default:
break;
@ -661,18 +668,19 @@ RUNTIME_FUNCTION(Runtime_AtomicsXor) {
RUNTIME_ASSERT(sta->GetBuffer()->is_shared());
RUNTIME_ASSERT(index < NumberToSize(isolate, sta->length()));
void* buffer = sta->GetBuffer()->backing_store();
uint8_t* source = static_cast<uint8_t*>(sta->GetBuffer()->backing_store()) +
NumberToSize(isolate, sta->byte_offset());
switch (sta->type()) {
#define TYPED_ARRAY_CASE(Type, typeName, TYPE, ctype, size) \
case kExternal##Type##Array: \
return DoXor<ctype>(isolate, buffer, index, value);
return DoXor<ctype>(isolate, source, index, value);
INTEGER_TYPED_ARRAYS(TYPED_ARRAY_CASE)
#undef TYPED_ARRAY_CASE
case kExternalUint8ClampedArray:
return DoXorUint8Clamped(isolate, buffer, index, value);
return DoXorUint8Clamped(isolate, source, index, value);
default:
break;
@ -692,18 +700,19 @@ RUNTIME_FUNCTION(Runtime_AtomicsExchange) {
RUNTIME_ASSERT(sta->GetBuffer()->is_shared());
RUNTIME_ASSERT(index < NumberToSize(isolate, sta->length()));
void* buffer = sta->GetBuffer()->backing_store();
uint8_t* source = static_cast<uint8_t*>(sta->GetBuffer()->backing_store()) +
NumberToSize(isolate, sta->byte_offset());
switch (sta->type()) {
#define TYPED_ARRAY_CASE(Type, typeName, TYPE, ctype, size) \
case kExternal##Type##Array: \
return DoExchange<ctype>(isolate, buffer, index, value);
return DoExchange<ctype>(isolate, source, index, value);
INTEGER_TYPED_ARRAYS(TYPED_ARRAY_CASE)
#undef TYPED_ARRAY_CASE
case kExternalUint8ClampedArray:
return DoExchangeUint8Clamped(isolate, buffer, index, value);
return DoExchangeUint8Clamped(isolate, source, index, value);
default:
break;

45
test/mjsunit/asm/atomics-add.js
View File

@ -4,14 +4,14 @@
// Flags: --harmony-sharedarraybuffer
function Module(stdlib, foreign, heap) {
function Module(stdlib, foreign, heap, offset) {
"use asm";
var MEM8 = new stdlib.Int8Array(heap);
var MEM16 = new stdlib.Int16Array(heap);
var MEM32 = new stdlib.Int32Array(heap);
var MEMU8 = new stdlib.Uint8Array(heap);
var MEMU16 = new stdlib.Uint16Array(heap);
var MEMU32 = new stdlib.Uint32Array(heap);
var MEM8 = new stdlib.Int8Array(heap, offset);
var MEM16 = new stdlib.Int16Array(heap, offset);
var MEM32 = new stdlib.Int32Array(heap, offset);
var MEMU8 = new stdlib.Uint8Array(heap, offset);
var MEMU16 = new stdlib.Uint16Array(heap, offset);
var MEMU32 = new stdlib.Uint32Array(heap, offset);
var add = stdlib.Atomics.add;
var fround = stdlib.Math.fround;
@ -61,9 +61,6 @@ function Module(stdlib, foreign, heap) {
};
}
var sab = new SharedArrayBuffer(16);
var m = Module(this, {}, sab);
function clearArray() {
var ui8 = new Uint8Array(sab);
for (var i = 0; i < sab.byteLength; ++i) {
@ -71,10 +68,10 @@ function clearArray() {
}
}
function testElementType(taConstr, f) {
function testElementType(taConstr, f, offset) {
clearArray();
var ta = new taConstr(sab);
var ta = new taConstr(sab, offset);
var name = Object.prototype.toString.call(ta);
assertEquals(0, f(0, 10), name);
assertEquals(10, ta[0]);
@ -85,9 +82,21 @@ function testElementType(taConstr, f) {
assertEquals(0, f(ta.length, 0), name);
}
testElementType(Int8Array, m.addi8);
testElementType(Int16Array, m.addi16);
testElementType(Int32Array, m.addi32);
testElementType(Uint8Array, m.addu8);
testElementType(Uint16Array, m.addu16);
testElementType(Uint32Array, m.addu32);
function testElement(m, offset) {
testElementType(Int8Array, m.addi8, offset);
testElementType(Int16Array, m.addi16, offset);
testElementType(Int32Array, m.addi32, offset);
testElementType(Uint8Array, m.addu8, offset);
testElementType(Uint16Array, m.addu16, offset);
testElementType(Uint32Array, m.addu32, offset);
}
var offset = 0;
var sab = new SharedArrayBuffer(16);
var m1 = Module(this, {}, sab, offset);
testElement(m1, offset);
offset = 32;
sab = new SharedArrayBuffer(64);
var m2 = Module(this, {}, sab, offset);
testElement(m2, offset);

45
test/mjsunit/asm/atomics-and.js
View File

@ -4,14 +4,14 @@
// Flags: --harmony-sharedarraybuffer
function Module(stdlib, foreign, heap) {
function Module(stdlib, foreign, heap, offset) {
"use asm";
var MEM8 = new stdlib.Int8Array(heap);
var MEM16 = new stdlib.Int16Array(heap);
var MEM32 = new stdlib.Int32Array(heap);
var MEMU8 = new stdlib.Uint8Array(heap);
var MEMU16 = new stdlib.Uint16Array(heap);
var MEMU32 = new stdlib.Uint32Array(heap);
var MEM8 = new stdlib.Int8Array(heap, offset);
var MEM16 = new stdlib.Int16Array(heap, offset);
var MEM32 = new stdlib.Int32Array(heap, offset);
var MEMU8 = new stdlib.Uint8Array(heap, offset);
var MEMU16 = new stdlib.Uint16Array(heap, offset);
var MEMU32 = new stdlib.Uint32Array(heap, offset);
var and = stdlib.Atomics.and;
var fround = stdlib.Math.fround;
@ -61,9 +61,6 @@ function Module(stdlib, foreign, heap) {
};
}
var sab = new SharedArrayBuffer(16);
var m = Module(this, {}, sab);
function clearArray() {
var ui8 = new Uint8Array(sab);
for (var i = 0; i < sab.byteLength; ++i) {
@ -71,10 +68,10 @@ function clearArray() {
}
}
function testElementType(taConstr, f) {
function testElementType(taConstr, f, offset) {
clearArray();
var ta = new taConstr(sab);
var ta = new taConstr(sab, offset);
var name = Object.prototype.toString.call(ta);
ta[0] = 0x7f;
assertEquals(0x7f, f(0, 0xf), name);
@ -86,9 +83,21 @@ function testElementType(taConstr, f) {
assertEquals(0, f(ta.length, 0), name);
}
testElementType(Int8Array, m.andi8);
testElementType(Int16Array, m.andi16);
testElementType(Int32Array, m.andi32);
testElementType(Uint8Array, m.andu8);
testElementType(Uint16Array, m.andu16);
testElementType(Uint32Array, m.andu32);
function testElement(m, offset) {
testElementType(Int8Array, m.andi8, offset);
testElementType(Int16Array, m.andi16, offset);
testElementType(Int32Array, m.andi32, offset);
testElementType(Uint8Array, m.andu8, offset);
testElementType(Uint16Array, m.andu16, offset);
testElementType(Uint32Array, m.andu32, offset);
}
var offset = 0;
var sab = new SharedArrayBuffer(16);
var m1 = Module(this, {}, sab, offset);
testElement(m1, offset);
offset = 32;
sab = new SharedArrayBuffer(64);
var m2 = Module(this, {}, sab, offset);
testElement(m2, offset);

45
test/mjsunit/asm/atomics-compareexchange.js
View File

@ -4,14 +4,14 @@
// Flags: --harmony-sharedarraybuffer
function Module(stdlib, foreign, heap) {
function Module(stdlib, foreign, heap, offset) {
"use asm";
var MEM8 = new stdlib.Int8Array(heap);
var MEM16 = new stdlib.Int16Array(heap);
var MEM32 = new stdlib.Int32Array(heap);
var MEMU8 = new stdlib.Uint8Array(heap);
var MEMU16 = new stdlib.Uint16Array(heap);
var MEMU32 = new stdlib.Uint32Array(heap);
var MEM8 = new stdlib.Int8Array(heap, offset);
var MEM16 = new stdlib.Int16Array(heap, offset);
var MEM32 = new stdlib.Int32Array(heap, offset);
var MEMU8 = new stdlib.Uint8Array(heap, offset);
var MEMU16 = new stdlib.Uint16Array(heap, offset);
var MEMU32 = new stdlib.Uint32Array(heap, offset);
var compareExchange = stdlib.Atomics.compareExchange;
var fround = stdlib.Math.fround;
@ -67,9 +67,6 @@ function Module(stdlib, foreign, heap) {
};
}
var sab = new SharedArrayBuffer(16);
var m = Module(this, {}, sab);
function clearArray() {
var ui8 = new Uint8Array(sab);
for (var i = 0; i < sab.byteLength; ++i) {
@ -77,10 +74,10 @@ function clearArray() {
}
}
function testElementType(taConstr, f, oobValue) {
function testElementType(taConstr, f, oobValue, offset) {
clearArray();
var ta = new taConstr(sab);
var ta = new taConstr(sab, offset);
var name = Object.prototype.toString.call(ta);
assertEquals(0, ta[0]);
assertEquals(0, f(0, 0, 50), name);
@ -93,9 +90,21 @@ function testElementType(taConstr, f, oobValue) {
assertEquals(oobValue, f(ta.length, 0, 0), name);
}
testElementType(Int8Array, m.compareExchangei8, 0);
testElementType(Int16Array, m.compareExchangei16, 0);
testElementType(Int32Array, m.compareExchangei32, 0);
testElementType(Uint8Array, m.compareExchangeu8, 0);
testElementType(Uint16Array, m.compareExchangeu16, 0);
testElementType(Uint32Array, m.compareExchangeu32, 0);
function testElement(m, offset) {
testElementType(Int8Array, m.compareExchangei8, 0, offset);
testElementType(Int16Array, m.compareExchangei16, 0, offset);
testElementType(Int32Array, m.compareExchangei32, 0, offset);
testElementType(Uint8Array, m.compareExchangeu8, 0, offset);
testElementType(Uint16Array, m.compareExchangeu16, 0, offset);
testElementType(Uint32Array, m.compareExchangeu32, 0, offset);
}
var offset = 0;
var sab = new SharedArrayBuffer(16);
var m1 = Module(this, {}, sab, offset);
testElement(m1, offset);
offset = 32;
sab = new SharedArrayBuffer(64);
var m2 = Module(this, {}, sab, offset);
testElement(m2, offset);

42
test/mjsunit/asm/atomics-exchange.js
View File

@ -4,14 +4,14 @@
// Flags: --harmony-sharedarraybuffer
function Module(stdlib, foreign, heap) {
function Module(stdlib, foreign, heap, offset) {
"use asm";
var MEM8 = new stdlib.Int8Array(heap);
var MEM16 = new stdlib.Int16Array(heap);
var MEM32 = new stdlib.Int32Array(heap);
var MEMU8 = new stdlib.Uint8Array(heap);
var MEMU16 = new stdlib.Uint16Array(heap);
var MEMU32 = new stdlib.Uint32Array(heap);
var MEM8 = new stdlib.Int8Array(heap, offset);
var MEM16 = new stdlib.Int16Array(heap, offset);
var MEM32 = new stdlib.Int32Array(heap, offset);
var MEMU8 = new stdlib.Uint8Array(heap, offset);
var MEMU16 = new stdlib.Uint16Array(heap, offset);
var MEMU32 = new stdlib.Uint32Array(heap, offset);
var exchange = stdlib.Atomics.exchange;
var fround = stdlib.Math.fround;
@ -71,10 +71,10 @@ function clearArray() {
}
}
function testElementType(taConstr, f) {
function testElementType(taConstr, f, offset) {
clearArray();
var ta = new taConstr(sab);
var ta = new taConstr(sab, offset);
var name = Object.prototype.toString.call(ta);
ta[0] = 0x7f;
assertEquals(0x7f, f(0, 0xf), name);
@ -84,9 +84,21 @@ function testElementType(taConstr, f) {
assertEquals(0, f(ta.length, 0), name);
}
testElementType(Int8Array, m.exchangei8);
testElementType(Int16Array, m.exchangei16);
testElementType(Int32Array, m.exchangei32);
testElementType(Uint8Array, m.exchangeu8);
testElementType(Uint16Array, m.exchangeu16);
testElementType(Uint32Array, m.exchangeu32);
function testElement(m, offset) {
testElementType(Int8Array, m.exchangei8, offset);
testElementType(Int16Array, m.exchangei16, offset);
testElementType(Int32Array, m.exchangei32, offset);
testElementType(Uint8Array, m.exchangeu8, offset);
testElementType(Uint16Array, m.exchangeu16, offset);
testElementType(Uint32Array, m.exchangeu32, offset);
}
var offset = 0;
var sab = new SharedArrayBuffer(16);
var m1 = Module(this, {}, sab, offset);
testElement(m1, offset);
offset = 32;
sab = new SharedArrayBuffer(64);
var m2 = Module(this, {}, sab, offset);
testElement(m2, offset);

45
test/mjsunit/asm/atomics-load.js
View File

@ -4,14 +4,14 @@
// Flags: --harmony-sharedarraybuffer
function Module(stdlib, foreign, heap) {
function Module(stdlib, foreign, heap, offset) {
"use asm";
var MEM8 = new stdlib.Int8Array(heap);
var MEM16 = new stdlib.Int16Array(heap);
var MEM32 = new stdlib.Int32Array(heap);
var MEMU8 = new stdlib.Uint8Array(heap);
var MEMU16 = new stdlib.Uint16Array(heap);
var MEMU32 = new stdlib.Uint32Array(heap);
var MEM8 = new stdlib.Int8Array(heap, offset);
var MEM16 = new stdlib.Int16Array(heap, offset);
var MEM32 = new stdlib.Int32Array(heap, offset);
var MEMU8 = new stdlib.Uint8Array(heap, offset);
var MEMU16 = new stdlib.Uint16Array(heap, offset);
var MEMU32 = new stdlib.Uint32Array(heap, offset);
var load = stdlib.Atomics.load;
var fround = stdlib.Math.fround;
@ -55,9 +55,6 @@ function Module(stdlib, foreign, heap) {
};
}
var sab = new SharedArrayBuffer(16);
var m = Module(this, {}, sab);
function clearArray() {
var ui8 = new Uint8Array(sab);
for (var i = 0; i < sab.byteLength; ++i) {
@ -65,10 +62,10 @@ function clearArray() {
}
}
function testElementType(taConstr, f, oobValue) {
function testElementType(taConstr, f, oobValue, offset) {
clearArray();
var ta = new taConstr(sab);
var ta = new taConstr(sab, offset);
var name = Object.prototype.toString.call(ta);
ta[0] = 10;
assertEquals(10, f(0), name);
@ -78,9 +75,21 @@ function testElementType(taConstr, f, oobValue) {
assertEquals(oobValue, f(ta.length), name);
}
testElementType(Int8Array, m.loadi8, 0);
testElementType(Int16Array, m.loadi16, 0);
testElementType(Int32Array, m.loadi32, 0);
testElementType(Uint8Array, m.loadu8, 0);
testElementType(Uint16Array, m.loadu16, 0);
testElementType(Uint32Array, m.loadu32, 0);
function testElement(m, offset) {
testElementType(Int8Array, m.loadi8, 0, offset);
testElementType(Int16Array, m.loadi16, 0, offset);
testElementType(Int32Array, m.loadi32, 0, offset);
testElementType(Uint8Array, m.loadu8, 0, offset);
testElementType(Uint16Array, m.loadu16, 0, offset);
testElementType(Uint32Array, m.loadu32, 0, offset);
}
var offset = 0;
var sab = new SharedArrayBuffer(16);
var m1 = Module(this, {}, sab, offset);
testElement(m1, offset);
offset = 32;
sab = new SharedArrayBuffer(64);
var m2 = Module(this, {}, sab, offset);
testElement(m2, offset);

42
test/mjsunit/asm/atomics-or.js
View File

@ -4,14 +4,14 @@
// Flags: --harmony-sharedarraybuffer
function Module(stdlib, foreign, heap) {
function Module(stdlib, foreign, heap, offset) {
"use asm";
var MEM8 = new stdlib.Int8Array(heap);
var MEM16 = new stdlib.Int16Array(heap);
var MEM32 = new stdlib.Int32Array(heap);
var MEMU8 = new stdlib.Uint8Array(heap);
var MEMU16 = new stdlib.Uint16Array(heap);
var MEMU32 = new stdlib.Uint32Array(heap);
var MEM8 = new stdlib.Int8Array(heap, offset);
var MEM16 = new stdlib.Int16Array(heap, offset);
var MEM32 = new stdlib.Int32Array(heap, offset);
var MEMU8 = new stdlib.Uint8Array(heap, offset);
var MEMU16 = new stdlib.Uint16Array(heap, offset);
var MEMU32 = new stdlib.Uint32Array(heap, offset);
var or = stdlib.Atomics.or;
var fround = stdlib.Math.fround;
@ -71,10 +71,10 @@ function clearArray() {
}
}
function testElementType(taConstr, f) {
function testElementType(taConstr, f, offset) {
clearArray();
var ta = new taConstr(sab);
var ta = new taConstr(sab, offset);
var name = Object.prototype.toString.call(ta);
assertEquals(0, f(0, 0xf), name);
assertEquals(0xf, ta[0]);
@ -85,9 +85,21 @@ function testElementType(taConstr, f) {
assertEquals(0, f(ta.length, 0), name);
}
testElementType(Int8Array, m.ori8);
testElementType(Int16Array, m.ori16);
testElementType(Int32Array, m.ori32);
testElementType(Uint8Array, m.oru8);
testElementType(Uint16Array, m.oru16);
testElementType(Uint32Array, m.oru32);
function testElement(m, offset) {
testElementType(Int8Array, m.ori8, offset);
testElementType(Int16Array, m.ori16, offset);
testElementType(Int32Array, m.ori32, offset);
testElementType(Uint8Array, m.oru8, offset);
testElementType(Uint16Array, m.oru16, offset);
testElementType(Uint32Array, m.oru32, offset);
}
var offset = 0;
var sab = new SharedArrayBuffer(16);
var m1 = Module(this, {}, sab, offset);
testElement(m1, offset);
offset = 32;
sab = new SharedArrayBuffer(64);
var m2 = Module(this, {}, sab, offset);
testElement(m2, offset);

45
test/mjsunit/asm/atomics-store.js
View File

@ -4,14 +4,14 @@
// Flags: --harmony-sharedarraybuffer
function Module(stdlib, foreign, heap) {
function Module(stdlib, foreign, heap, offset) {
"use asm";
var MEM8 = new stdlib.Int8Array(heap);
var MEM16 = new stdlib.Int16Array(heap);
var MEM32 = new stdlib.Int32Array(heap);
var MEMU8 = new stdlib.Uint8Array(heap);
var MEMU16 = new stdlib.Uint16Array(heap);
var MEMU32 = new stdlib.Uint32Array(heap);
var MEM8 = new stdlib.Int8Array(heap, offset);
var MEM16 = new stdlib.Int16Array(heap, offset);
var MEM32 = new stdlib.Int32Array(heap, offset);
var MEMU8 = new stdlib.Uint8Array(heap, offset);
var MEMU16 = new stdlib.Uint16Array(heap, offset);
var MEMU32 = new stdlib.Uint32Array(heap, offset);
var store = stdlib.Atomics.store;
var fround = stdlib.Math.fround;
@ -61,9 +61,6 @@ function Module(stdlib, foreign, heap) {
};
}
var sab = new SharedArrayBuffer(16);
var m = Module(this, {}, sab);
function clearArray() {
var ui8 = new Uint8Array(sab);
for (var i = 0; i < sab.byteLength; ++i) {
@ -71,10 +68,10 @@ function clearArray() {
}
}
function testElementType(taConstr, f, oobValue) {
function testElementType(taConstr, f, oobValue, offset) {
clearArray();
var ta = new taConstr(sab);
var ta = new taConstr(sab, offset);
var name = Object.prototype.toString.call(ta);
assertEquals(10, f(0, 10), name);
assertEquals(10, ta[0]);
@ -83,9 +80,21 @@ function testElementType(taConstr, f, oobValue) {
assertEquals(oobValue, f(ta.length, 0), name);
}
testElementType(Int8Array, m.storei8, 0);
testElementType(Int16Array, m.storei16, 0);
testElementType(Int32Array, m.storei32, 0);
testElementType(Uint8Array, m.storeu8, 0);
testElementType(Uint16Array, m.storeu16, 0);
testElementType(Uint32Array, m.storeu32, 0);
function testElement(m, offset) {
testElementType(Int8Array, m.storei8, 0, offset);
testElementType(Int16Array, m.storei16, 0, offset);
testElementType(Int32Array, m.storei32, 0, offset);
testElementType(Uint8Array, m.storeu8, 0, offset);
testElementType(Uint16Array, m.storeu16, 0, offset);
testElementType(Uint32Array, m.storeu32, 0, offset);
}
var offset = 0;
var sab = new SharedArrayBuffer(16);
var m1 = Module(this, {}, sab, offset);
testElement(m1, offset);
offset = 32;
sab = new SharedArrayBuffer(64);
var m2 = Module(this, {}, sab, offset);
testElement(m2, offset);

45
test/mjsunit/asm/atomics-sub.js
View File

@ -4,14 +4,14 @@
// Flags: --harmony-sharedarraybuffer
function Module(stdlib, foreign, heap) {
function Module(stdlib, foreign, heap, offset) {
"use asm";
var MEM8 = new stdlib.Int8Array(heap);
var MEM16 = new stdlib.Int16Array(heap);
var MEM32 = new stdlib.Int32Array(heap);
var MEMU8 = new stdlib.Uint8Array(heap);
var MEMU16 = new stdlib.Uint16Array(heap);
var MEMU32 = new stdlib.Uint32Array(heap);
var MEM8 = new stdlib.Int8Array(heap, offset);
var MEM16 = new stdlib.Int16Array(heap, offset);
var MEM32 = new stdlib.Int32Array(heap, offset);
var MEMU8 = new stdlib.Uint8Array(heap, offset);
var MEMU16 = new stdlib.Uint16Array(heap, offset);
var MEMU32 = new stdlib.Uint32Array(heap, offset);
var sub = stdlib.Atomics.sub;
var fround = stdlib.Math.fround;
@ -61,9 +61,6 @@ function Module(stdlib, foreign, heap) {
};
}
var sab = new SharedArrayBuffer(16);
var m = Module(this, {}, sab);
function clearArray() {
var ui8 = new Uint8Array(sab);
for (var i = 0; i < sab.byteLength; ++i) {
@ -71,10 +68,10 @@ function clearArray() {
}
}
function testElementType(taConstr, f) {
function testElementType(taConstr, f, offset) {
clearArray();
var ta = new taConstr(sab);
var ta = new taConstr(sab, offset);
var name = Object.prototype.toString.call(ta);
ta[0] = 30;
assertEquals(30, f(0, 10), name);
@ -86,9 +83,21 @@ function testElementType(taConstr, f) {
assertEquals(0, f(ta.length, 0), name);
}
testElementType(Int8Array, m.subi8);
testElementType(Int16Array, m.subi16);
testElementType(Int32Array, m.subi32);
testElementType(Uint8Array, m.subu8);
testElementType(Uint16Array, m.subu16);
testElementType(Uint32Array, m.subu32);
function testElement(m, offset) {
testElementType(Int8Array, m.subi8, offset);
testElementType(Int16Array, m.subi16, offset);
testElementType(Int32Array, m.subi32, offset);
testElementType(Uint8Array, m.subu8, offset);
testElementType(Uint16Array, m.subu16, offset);
testElementType(Uint32Array, m.subu32, offset);
}
var offset = 0;
var sab = new SharedArrayBuffer(16);
var m1 = Module(this, {}, sab, offset);
testElement(m1, offset);
offset = 32;
sab = new SharedArrayBuffer(64);
var m2 = Module(this, {}, sab, offset);
testElement(m2, offset);

45
test/mjsunit/asm/atomics-xor.js
View File

@ -4,14 +4,14 @@
// Flags: --harmony-sharedarraybuffer
function Module(stdlib, foreign, heap) {
function Module(stdlib, foreign, heap, offset) {
"use asm";
var MEM8 = new stdlib.Int8Array(heap);
var MEM16 = new stdlib.Int16Array(heap);
var MEM32 = new stdlib.Int32Array(heap);
var MEMU8 = new stdlib.Uint8Array(heap);
var MEMU16 = new stdlib.Uint16Array(heap);
var MEMU32 = new stdlib.Uint32Array(heap);
var MEM8 = new stdlib.Int8Array(heap, offset);
var MEM16 = new stdlib.Int16Array(heap, offset);
var MEM32 = new stdlib.Int32Array(heap, offset);
var MEMU8 = new stdlib.Uint8Array(heap, offset);
var MEMU16 = new stdlib.Uint16Array(heap, offset);
var MEMU32 = new stdlib.Uint32Array(heap, offset);
var xor = stdlib.Atomics.xor;
var fround = stdlib.Math.fround;
@ -61,9 +61,6 @@ function Module(stdlib, foreign, heap) {
};
}
var sab = new SharedArrayBuffer(16);
var m = Module(this, {}, sab);
function clearArray() {
var ui8 = new Uint8Array(sab);
for (var i = 0; i < sab.byteLength; ++i) {
@ -71,10 +68,10 @@ function clearArray() {
}
}
function testElementType(taConstr, f) {
function testElementType(taConstr, f, offset) {
clearArray();
var ta = new taConstr(sab);
var ta = new taConstr(sab, offset);
var name = Object.prototype.toString.call(ta);
assertEquals(0, f(0, 0xf), name);
assertEquals(0xf, ta[0]);
@ -85,9 +82,21 @@ function testElementType(taConstr, f) {
assertEquals(0, f(ta.length, 0), name);
}
testElementType(Int8Array, m.xori8);
testElementType(Int16Array, m.xori16);
testElementType(Int32Array, m.xori32);
testElementType(Uint8Array, m.xoru8);
testElementType(Uint16Array, m.xoru16);
testElementType(Uint32Array, m.xoru32);
function testElement(m, offset) {
testElementType(Int8Array, m.xori8, offset);
testElementType(Int16Array, m.xori16, offset);
testElementType(Int32Array, m.xori32, offset);
testElementType(Uint8Array, m.xoru8, offset);
testElementType(Uint16Array, m.xoru16, offset);
testElementType(Uint32Array, m.xoru32, offset);
}
var offset = 0;
var sab = new SharedArrayBuffer(16);
var m1 = Module(this, {}, sab, offset);
testElement(m1, offset);
offset = 32;
sab = new SharedArrayBuffer(64);
var m2 = Module(this, {}, sab, offset);
testElement(m2, offset);

231
test/mjsunit/harmony/atomics.js
View File

@ -77,12 +77,13 @@ function testAtomicOp(op, ia, index, expectedIndex, 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);
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);
@ -109,6 +110,20 @@ function testAtomicOp(op, ia, index, expectedIndex, 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) {
@ -128,39 +143,53 @@ function testAtomicOp(op, ia, index, expectedIndex, 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);
}
})
});
})();
@ -168,13 +197,18 @@ function testAtomicOp(op, ia, index, expectedIndex, name) {
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);
}
})
});
})();
@ -182,14 +216,19 @@ function testAtomicOp(op, ia, index, expectedIndex, name) {
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);
}
})
});
})();
@ -197,14 +236,19 @@ function testAtomicOp(op, ia, index, expectedIndex, name) {
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);
}
})
});
})();
@ -212,15 +256,20 @@ function testAtomicOp(op, ia, index, expectedIndex, name) {
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);
}
})
});
})();
@ -228,15 +277,20 @@ function testAtomicOp(op, ia, index, expectedIndex, name) {
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);
}
})
});
})();
@ -244,15 +298,20 @@ function testAtomicOp(op, ia, index, expectedIndex, name) {
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);
}
})
});
})();
@ -260,15 +319,20 @@ function testAtomicOp(op, ia, index, expectedIndex, name) {
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);
}
})
});
})();
@ -276,15 +340,20 @@ function testAtomicOp(op, ia, index, expectedIndex, name) {
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);
}
})
});
})();