1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
|
// |reftest| skip-if(!xulRuntime.shell)
/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
/*
* Any copyright is dedicated to the Public Domain.
* http://creativecommons.org/licenses/publicdomain/
*/
if (!(this.SharedArrayBuffer && this.getSharedArrayBuffer && this.setSharedArrayBuffer)) {
reportCompare(true,true);
quit(0);
}
var DEBUG = false;
function dprint(s) {
if (DEBUG) print(s);
}
// Tests the SharedArrayBuffer mailbox in the shell.
// Tests the wait/wake functionality in the shell.
var sab = new SharedArrayBuffer(12);
var mem = new Int32Array(sab);
// SharedArrayBuffer mailbox tests
assertEq(getSharedArrayBuffer(), null); // Mbx starts empty
assertEq(setSharedArrayBuffer(mem.buffer), undefined); // Setter returns undefined
assertEq(getSharedArrayBuffer() == null, false); // And then the mbx is not empty
var v = getSharedArrayBuffer();
assertEq(v.byteLength, mem.buffer.byteLength); // Looks like what we put in?
var w = new Int32Array(v);
mem[0] = 314159;
assertEq(w[0], 314159); // Shares memory (locally) with what we put in?
mem[0] = 0;
setSharedArrayBuffer(null); // Setting to null clears to null
assertEq(getSharedArrayBuffer(), null);
setSharedArrayBuffer(mem.buffer);
setSharedArrayBuffer(undefined); // Setting to undefined clears to null
assertEq(getSharedArrayBuffer(), null);
setSharedArrayBuffer(mem.buffer);
setSharedArrayBuffer(); // Setting without arguments clears to null
assertEq(getSharedArrayBuffer(), null);
// Only SharedArrayBuffer can be stored in the mbx
assertThrowsInstanceOf(() => setSharedArrayBuffer({x:10, y:20}), Error);
assertThrowsInstanceOf(() => setSharedArrayBuffer([1,2]), Error);
assertThrowsInstanceOf(() => setSharedArrayBuffer(new ArrayBuffer(10)), Error);
assertThrowsInstanceOf(() => setSharedArrayBuffer(new Int32Array(10)), Error);
assertThrowsInstanceOf(() => setSharedArrayBuffer(false), Error);
assertThrowsInstanceOf(() => setSharedArrayBuffer(3.14), Error);
assertThrowsInstanceOf(() => setSharedArrayBuffer(mem), Error);
assertThrowsInstanceOf(() => setSharedArrayBuffer("abracadabra"), Error);
assertThrowsInstanceOf(() => setSharedArrayBuffer(() => 37), Error);
// Futex test
if (helperThreadCount() === 0) {
// Abort if there is no helper thread.
reportCompare(true,true);
quit();
}
////////////////////////////////////////////////////////////
// wait() returns "not-equal" if the value is not the expected one.
mem[0] = 42;
assertEq(Atomics.wait(mem, 0, 33), "not-equal");
// wait() returns "timed-out" if it times out
assertEq(Atomics.wait(mem, 0, 42, 100), "timed-out");
////////////////////////////////////////////////////////////
// Main is sharing the buffer with the worker; the worker is clearing
// the buffer.
mem[0] = 42;
mem[1] = 37;
mem[2] = DEBUG;
setSharedArrayBuffer(mem.buffer);
evalInWorker(`
var mem = new Int32Array(getSharedArrayBuffer());
function dprint(s) {
if (mem[2]) print(s);
}
assertEq(mem[0], 42); // what was written in the main thread
assertEq(mem[1], 37); // is read in the worker
mem[1] = 1337;
dprint("Sleeping for 2 seconds");
sleep(2);
dprint("Waking the main thread now");
setSharedArrayBuffer(null);
assertEq(Atomics.wake(mem, 0, 1), 1); // Can fail spuriously but very unlikely
`);
var then = Date.now();
assertEq(Atomics.wait(mem, 0, 42), "ok");
dprint("Woke up as I should have in " + (Date.now() - then)/1000 + "s");
assertEq(mem[1], 1337); // what was written in the worker is read in the main thread
assertEq(getSharedArrayBuffer(), null); // The worker's clearing of the mbx is visible
////////////////////////////////////////////////////////////
// Test the default argument to atomics.wake()
setSharedArrayBuffer(mem.buffer);
evalInWorker(`
var mem = new Int32Array(getSharedArrayBuffer());
sleep(2); // Probably long enough to avoid a spurious error next
assertEq(Atomics.wake(mem, 0), 1); // Last argument to wake should default to +Infinity
`);
var then = Date.now();
dprint("Main thread waiting on wakeup (2s)");
assertEq(Atomics.wait(mem, 0, 42), "ok");
dprint("Woke up as I should have in " + (Date.now() - then)/1000 + "s");
////////////////////////////////////////////////////////////
// A tricky case: while in the wait there will be an interrupt, and in
// the interrupt handler we will execute a wait. This is
// explicitly prohibited (for now), so there should be a catchable exception.
var exn = false;
timeout(2, function () {
dprint("In the interrupt, starting inner wait with timeout 2s");
try {
Atomics.wait(mem, 0, 42); // Should throw
} catch (e) {
dprint("Got the interrupt exception!");
exn = true;
}
return true;
});
try {
dprint("Starting outer wait");
assertEq(Atomics.wait(mem, 0, 42, 5000), "timed-out");
}
finally {
timeout(-1);
}
assertEq(exn, true);
////////////////////////////////////////////////////////////
dprint("Done");
reportCompare(true,true);
|
