Revised: 2016-01-22
14 | 15 |This document defines the changes and amendments to asm.js 19 | semantics to support 20 | the proposal for ECMAScript shared memory and atomics. 21 | Please refer to that document for full information about the semantics.
22 | 23 |This specification is a restatement of 24 | an earlier work, 25 | along with later bug fixes. The earlier work is obsolete.
26 | 27 |Changelog:
28 |An "integer-typed array" is one of the ~TypedArray~ views ~Int8Array~, ~Uint8Array~, ~Int16Array~, ~Uint16Array~, ~Int32Array~, and ~Uint32Array~.
39 | 40 |A "float-typed array" is one of the TypedArray views ~Float32Array~ and ~Float64Array~.
41 |The heap memory passed to the asm.js module at link time must be 47 | a ~SharedArrayBuffer~ if and only if the module references the 48 | ~Atomics~ object (see below). If this constraint fails then a 49 | soft link error ensues and execution falls back to non-asm.js, cf 50 | the asm.js spec section 7.
51 | 52 |There is a new known stdlib object ~Atomics~. This object 58 | provides a number of known, static methods, a subset of the 59 | methods provided in the full specification. The atomic operations 60 | have the same dynamic semantics in asm.js as in full JS.
61 | 62 |The following Atomics names are not available as intrinsics in asm.js:
64 |The futex methods can be accessed through the FFI (with the 74 | heap passed implicitly) and the operation result values can be 75 | expanded into constant values, as they have known values.
76 | 77 |The _view_ must name an integer-typed array mapped onto 86 | shared memory.
87 | 88 |The _index_ must be an expression of static type Intish. If 89 | the element byte size of _view_ is not 1 then _index_ must have 90 | the form _C_, where _C_ is a constant, or the form _E>>K_, where 91 | _E_ is some expression and _K_ is a constant that is the 92 | log-base-2 of the element byte size of _view_.
93 | 94 |The result type of Atomics.load is Int.
95 | 96 |Treating atomic accesses as "syntax" rather than as 98 | "calls" -- ie, requiring a shift for the index expression -- 99 | fits in with how they will be used and allows for 100 | simplifictions in code generation.
101 |The _view_ and _index_ arguments are constrained as for Atomics.load.
113 | 114 |The _value_ must be an expression of static type Intish.
115 | 116 |The result type of Atomics.store is the actual type of _value_.
117 |The _view_, _index_, and _value_ arguments are constrained as for Atomics.store.
127 | 128 |The result type of Atomics.exchange is Int.
129 |As for Atomics.exchange.
137 | 138 |As for Atomics.exchange.
144 | 145 |As for Atomics.exchange.
151 | 152 |As for Atomics.exchange.
158 | 159 |As for Atomics.exchange.
165 | 166 |The _view_ and _index_ arguments are constrained as for Atomics.load.
174 | 175 |The _expected_ and _replacement_ arguments must be 176 | expressions of static type Intish.
177 | 178 |The result type of Atomics.compareExchange is Int.
179 |Implements a full memory barrier.
187 | 188 |Atomics.fence() is no longer a part of the Shared Memory and 190 | Atomics specification and we do not expect to reintroduce it. 191 | It is implemented in Firefox, for now, but will likely be removed.
192 |The result type of Atomics.fence is void.
198 | 199 |The _size_ argument must be an integer constant.
209 | 210 |
The result type of Atomics.isLockFree is Int, a boolean value.
211 | 212 |Again, treating Atomics.isLockFree as syntax rather than 214 | as a call fits in with how it will be used and provides 215 | guarantees that it will be resolved at compile time.
216 |Revised: 2016-08-03
14 | 15 |For Shared Memory and Atomics to be useful in the browser we must modify some DOM APIs to work with shared memory. At a minimum we need a method for sharing a SharedArrayBuffer among agents, but it is also useful to allow some WebGL APIs to operate on shared memory so as to avoid the overhead of copying large data arrays.
19 | 20 |TODO - mine information from older spec docs and tickets and discussions to go here
21 | 22 |A normal agent cluster shall comprise a single HTML document and its direct (and indirect, if nested workers are supported) Web Worker children.
31 | 32 |Thus a document within a frame element is never in the same agent cluster as its parent document. The reason for this is partly that it is a conservative design that can be loosened later, and also that it is possible for the outer and inner documents to be in different content processes, making sharing memory difficult.
34 |A special agent cluster is any agent cluster other than a normal agent cluster. Every special agent cluster shall comprise only a single agent.
37 | 38 |Thus SharedWorkers and ServiceWorkers are agent clusters by themselves. The reason for this is largely that a normal agent cluster can be suspended or removed without SharedWorkers and ServiceWorkers being aware of that, and if the latter share memory with the cluster a deadlock can ensue as a shared-memory communication from the cluster is forever delayed. A secondary reason is that eg a ServiceWorker can be in a different content process from the documents using it, making sharing memory difficult.
40 |(Spec draft note) If an agent like a SharedWorker can create its own WebWorkers then we really would like those to be within the agent cluster of the SharedWorker. But the WHATWG spec seems mum on nested workers in general.
44 |When a web worker is created the embedding may delay actually starting the worker until the creating agent returns to its event loop.
52 | 53 |Firefox has that constraint, and the architecture is unlikely to change. It is a possible source of non-portability that other browsers may be able to start the worker immediately.
55 |In contrast, the WHATWG spec requires the worker to be started immediately (steps 10 and 11 of the worker creation algorithm).
56 |If a web worker cannot be created (for example, because a thread cannot be created for it) then an error must be signaled by firing an Error event at the creating agent (as for failing to load the URL for the worker).
59 |Each web worker shall run on a dedicated preemptable thread ("real thread") in order to guarantee forward progress.
65 | 66 |If an agent in a cluster is terminated by the implementation then the entire agent cluster it is part of shall be terminated.
72 | 73 |That behavior is chosen as there exists no reliable termination signaling mechanism today. The SAB proposal requires either termination en masse or a signaling mechanism.
75 | 76 |Current browsers probably do not randomly terminate workers, but terminate them only when the page they belong to is removed from the browser (purged from the tab's history, or the tab is closed). Thus current browsers probably get this right already.
77 |The exclusive method for causing memory to be shared between agents shall be to send a SharedArrayBuffer from one agent in the cluster to another using `postMessage` and structured cloning.
85 | 86 |The structured clone algorithm accepts SharedArrayBuffers and TypedArrays mapped onto SharedArrayBuffers. In both cases, the SharedArrayBuffer object is transmitted to the receiver resulting in a new, private SharedArrayBuffer object in the receiving agent (just as for ArrayBuffer). However, the Shared Data Block referenced by the two SharedArrayBuffer objects is the same data block, and a side effect to the block in one agent will eventually become visible in the other agent, following the semantics in the ES262 proposal.
87 | 88 |A SharedArrayBuffer is not a Transferable object in the sense of HTML.
89 | 90 |Thus if a SharedArrayBuffer object is present in the transfer list then `postMessage` will throw a DataCloneError.
92 | 93 |In draft versions of the Shared Memory and Atomics spefification the SharedArrayBuffer was required to be present in the transfer list in the `postMessage` call.
94 |If the sender and receiver are not part of the same agent cluster then then the receiver shall receive a SharedArrayBuffer object that references a new Shared Data Block with byte length zero and not the Shared Data Block that was sent.
97 | 98 |The sender can't tell if the message is sent to a valid receiver since it may be sending on a MessageChannel that is not connected with a receiver.
100 | 101 |(Spec draft note) Instead of receiving a zero-length block the receiver could receive some sort of error.
102 |Modify the WebGL 1.0 spec as follows.
110 | 111 |Change the type of `ArrayBufferView` to be a view whose buffer is exclusively an ArrayBuffer, ie, not a SharedArrayBuffer.
112 | 113 |That probably depends on some kind of predicate mechanism, TBD, but the concept is easy enough, it is just an additional run-time check. A reasonable implementation of the check is just a load/compare/conditional branch triplet.
115 |Introduce a type `ArrayBufferViewMaybeShared` to be any view type, ie, equivalent to the old definition of `ArrayBufferView`.
118 | 119 |Introduce a type `BufferDataSourceMaybeShared`:
120 |`typedef (ArrayBuffer or SharedArrayBuffer or ArrayBufferViewMaybeShared) BufferDataSourceMaybeShared`
121 | 122 |Replace every occurrence of `BufferDataSource` in signatures with `BufferDataSourceMaybeShared`, ie, in the signatures of these functions: `bufferData`, `bufferSubData`.
123 | 124 |Replace every occurrence of `ArrayBufferView` in signatures with `ArrayBufferViewMaybeShared`, ie in the signatures of these functions: `compressedTexImage2D`, `compressedTexSubImage2D`, `readPixels`, `texImage2D`, `texSubImage2D`.
125 | 126 |Also see the NOTE on GetValueFromBuffer() that clarifies 16 | that a compiler may not generate re-loads from shared 17 | memory.
18 | ]]] 19 | 20 | What does it mean for the shared memory model to leak into the spec? 21 | 22 | "Only with data races do optimizations become visible to the program." 23 | 24 | This is mostly about data races, I think - given that we're 25 | sequentially consistent absent data races, confusing behavior is a 26 | result of counterintuitive results about races. (For example the racy 27 | busy-wait loop.) That a read from a racy location can yield garbage 28 | and that that garbage can be any type-safe value is confusing, people 29 | don't think of garbage as "we skip the reading altogether and reuse 30 | the value we read last time". 31 | 32 | (But is it *only* about data races? Consider the buggy synchronization 33 | for the barrier, that required a seqLock to fix. Was that code racy? 34 | Probably not. It just did not perform inter-thread synchronization 35 | properly. Is this a normal bug or a new kind of bug?) 36 | 37 | Right now races can be hidden by syntax because we use TypedArray also 38 | for shared memory. That is, the semantic "leak" is deep in the 39 | language, at the memory access level and as (declaratively) specified 40 | by the memory model. 41 | 42 | If, instead, shared memory was accessed entirely along another path 43 | then the "leak" would be clearly set apart from existing machinery, 44 | and it would be obvious that code that does not call the shared memory 45 | primitives does not access shared memory and is not subject to racy 46 | behavior. 47 | 48 | The question is how much that is worth. Suppose shared memory use is 49 | packaged in a library but has some code that turns out to be racy. 50 | This raciness may or will spread to the client code. But is this more 51 | than just a bug? It is, when values that should not possibly exist 52 | come back as return values from the library. But again, is that more 53 | than just a bug? (Especially in a dynamic language.) 54 | 55 | -- 56 | 57 | How are the language semantics affected by races? 58 | 59 | - GetValueFromBuffer may return garbage 60 | 61 | - SetValueInBuffer may store garbage 62 | 63 | - The garbage may not actually be stable (for a period that's very 64 | hard to pin down) 65 | 66 | - The garbage is always type safe though: NaNs are still canonicalized 67 | 68 | - Once garbage is in memory it spreads: eg, a branch based on a 69 | garbage value may go either way, an array store using a garbage 70 | index may store into any slot (or out of bounds) 71 | 72 | - Multiple reads of the same garbage may read different values, which 73 | affects program logic 74 | 75 | We can perhaps *model* this by saying, in GetValueFromBuffer, that if 76 | the location has been subject to a race then random byte values are 77 | read by steps 9a, 10a, and 11a. 78 | 79 | But that requires pinning down whether a particular location has been 80 | subject to a race. The union-of-locations rule is a good start but is 81 | it reliable? 82 | 83 | If an operation uses racy data, does the operation itself become part 84 | of the race? Are data it stores also racy? I would be inclined to 85 | say not, since racy values that are read are type-safe and once read 86 | they stay read, except that re-reading is an issue: a value that is 87 | re-read (by the compiler) may read a different value. 88 | 89 | And what about reordering in the CPU? 90 | 91 | When does the race end? Suppose N writes race on a location L; at 92 | some (global) time the last of those has completed. How does the race 93 | end? A regular read to L will be racy. An atomic store to L will 94 | also be racy (races with a non-atomic store). 95 | 96 | The race therefore ends only when the threads synchronize on other 97 | locations than L, creating a relationship between the racy accesses on 98 | L and those synchronizations, and decoupling accesses to L after the 99 | synchronization from the ones before. 100 | 101 | The threads don't all have to synchronize on the same other-than-L 102 | location because seqcst - the syncs are ordered, the order does not 103 | matter. But they must all *synchronize*, I think, that were involved 104 | in the race on L, it's not enough to interact with an atomic var. 105 | Suppose two threads T1 and T2 and two sync locations S1 and S2. They 106 | race to write on L. Now T1 writes S1 and T2 writes S2. Those writes 107 | are ordered, and both happen after the race on L, and both threads can 108 | therefore assume that the race is over - but only after both events. 109 | But since T1 and T2 are not aware of the other's event, they never 110 | know when that is. One must still signal the other (arguaby they must 111 | perhaps signal each other). 112 | 113 | Thus: the race is over once all the racing threads have synchronized 114 | properly with each other after the race, which means created a 115 | happened-before relationship that involves all of them both sending a 116 | signal and receiving a signal. 117 | 118 | Effectively this means a global atomic counter reaching N, where each 119 | thread counts up. 120 | 121 | 122 | 123 | Until the race is known to be over there's no telling what will be 124 | written to or read from a racy location. 125 | -------------------------------------------------------------------------------- /issues/TimingAttack.md: -------------------------------------------------------------------------------- 1 | # Shared memory: Side-channel information leaks 2 | 3 | lhansen@mozilla.com / updated 2016-01-24, minor changes 2016-07-20 4 | 5 | ## Introduction 6 | 7 | It is possible to create a high-resolution timer by using shared 8 | memory and a worker: the worker runs in a loop that increments a 9 | shared cell with an atomic operation, and whatever agent needs a clock 10 | just reads the cell. Yossi Oren has measured such a cell to have a 11 | 4ns resolution on current (2015) hardware. The clock will be a little 12 | noisy as a result of system behavior but probably has much higher 13 | resolution in practice than the attenuated `performance.now()` timer, 14 | which has 5μs resolution. 15 | 16 | A number of side channel attacks need a high-resolution timing source 17 | to work. (This is why `performance.now()` resolution has been reduced.) 18 | There are several examples of such attacks in JS, including last-level 19 | cache sniffing to extract user behavior or user data [Oren, 1], row 20 | hammering to cause bit flips in memory on some types of hardware [Gruss et al, 2], 21 | and SVG/CSS attacks that can read pixels using transforms [Stone, 3] [Andrysco et al, 4]. In 22 | virtualized server environments, though not yet in JS, it has been 23 | possible to extract cryptographic keys for AES and RSA from the cache 24 | [Osvik et al, 5] [Inci et al, 6]. Several published papers focus on exfiltration of data as a high-value use of JS, wherein a local attacker process would signal data by accessing its memory and the JS code, having legitimate access to the network from within the browser, would detect those signals and upload the data. 25 | 26 | Attacks are also being launched against ARM [Lipp et al, 8] 27 | and there are ever-novel attack vectors [Gruss et al, 9]; the relevance 28 | of those attacks to JS is hazy, at this time. 29 | 30 | In these cases, a precise timer is needed to distinguish a fast 31 | operation from a slow operation. For the cache attacks and row 32 | hammering this is the time difference between a cache hit and a cache 33 | miss; for the SVG/CSS attacks it is the difference between a fast 34 | transform (the bit we're reading is set one way) and a slow one (it's 35 | set the other way). Without a fast timer these attacks are not 36 | effective. 37 | 38 | ## Mitigations and countermeasures 39 | 40 | ### Thread affinity 41 | 42 | The only reasonable "hidden" mitigation that's been proposed and that 43 | can be implemented by the browser vendors is to make sure that threads 44 | that share memory have affinity to the same CPU. In that case, the 45 | thread that generates the clock signal does not run in parallel with 46 | the thread that reads it, as they are timesliced on the same core. 47 | The clock signal is thus destroyed. (Or so the theory goes.) 48 | 49 | In favor of that mitigation is that it does not destroy the 50 | shared-memory feature; workers can still share memory, and can share 51 | the memory with their owning main thread. 52 | 53 | However, actual parallel execution is destroyed by setting the 54 | affinity in that manner, thus removing one of the main justifications 55 | for the feature in JS, and probably making programs that use shared 56 | memory less effective than programs that copy memory. In practice, 57 | requiring affinity may be a reasonable default if it can be changed 58 | easily when needed, or it may be a reasonable option for high-security 59 | environments such as Tor [Tor project, 7], but it is not a reasonable mitigation when 60 | shared-memory parallelism is actually needed. 61 | 62 | The affinity solution has another couple of problems: 63 | 64 | - Thread affinity has real teeth on Windows and Linux but is not well 65 | supported on Mac OS X (and may not be well supported on other 66 | platforms). 67 | - Browsers that have a single main thread that is the main thread for 68 | all or many tabs (as does Firefox at the moment) will end up forcing 69 | many worker threads onto the same core, if shared memory becomes popular on 70 | the web and affinity is enabled by default. 71 | 72 | ### Opt-in 73 | 74 | At the moment several browsers implement an opt-in scheme for plugin 75 | content. It may be possible to implement something similar for shared 76 | memory, whereby (say) the shared memory APIs are available but with 77 | thread affinity enabled by default, and some user action allows 78 | threads to run free on multiple cores. Like the plugin content, it 79 | could be a per-domain or per-tab permission, set once and for all or 80 | for a shorter duration. 81 | 82 | Opt-in is not a great solution because most users will not know what 83 | they opt in to, so it will be confusing, and the security will be 84 | questionable (most users run all plugins always when prompted). It's 85 | also not clear how the need to opt in would be communicated to the 86 | page. 87 | 88 | (Also, as discussed above, thread affinity is not necessarily controllable, 89 | and in practice the default might need to be that the shared-memory feature 90 | is not available, or that it is available in some attenuated form.) 91 | 92 | ## How bad is it? 93 | 94 | ### Known and potential impact 95 | 96 | We don't really know how bad this attack is. The published attacks in 97 | JS are not yet devastating, but attacks only get better. The web is 98 | vast; an attack that works against many computers and is delivered via 99 | an ad, say, can be very bad. Or the attack can go into a toolbox for 100 | targeted attacks (APT). 101 | 102 | In general, a web browser runs untrusted code and for that code to be 103 | able to steal information from the user is a big deal. 104 | 105 | 106 | ### New impact 107 | 108 | The thing is, it's not obvious that the attack provides a genuinely 109 | new capability to attackers. Consider the existing technologies on 110 | the Web that can be used to mount the cache attacks: 111 | 112 | - Flash Player (AS3 has shared memory) 113 | - Java 114 | - PNaCl / NaCl 115 | - browser extensions with native code 116 | - native messaging in Chrome 117 | - js-ctypes in Firefox 118 | - ActiveX in Internet Explorer 119 | - probably more 120 | 121 | In all cases those technologies do not need shared memory at all if 122 | they already have a precise clock for the attack, but absent a precise 123 | clock all do have shared memory and can build such a clock. 124 | 125 | Java and ActiveX were brought up already in 2005 by Osvik in his 126 | paper on attacking AES [5]. 127 | 128 | In addition, several of the published attacks do not appear to need 129 | the new clock: the rowhammer.js authors have said that the 5μs 130 | throttled clock is not a hindrance to them; Oren states that a 1μs 131 | clock is sufficient for cache sniffing, and such a clock can be built 132 | (by counting) from the 5μs clock. 133 | 134 | The shared-memory clock might affect the SVG/CSS attack, especially as 135 | implemented for exploiting subnormal timings, although that attack is 136 | not an issue at present. (In Firefox the computation was first made 137 | timing-independent and later pushed to the GPU.) 138 | 139 | None of the attacks appear to be aided by being able to allocate 140 | memory that is merely shared among the threads of the same browser 141 | process. (The attacks bring up "shared memory" as an attack vector, 142 | but this is in order to play memory mapping tricks.) 143 | 144 | 145 | ### Future impact 146 | 147 | In the future, if WebAssembly adds shared memory and threads (as it is 148 | expected it will) it will inevitably run into the same problem. 149 | 150 | 151 | ### Server-side impact 152 | 153 | node.js is not all that interesting in this context because it only 154 | runs trusted code. Clearly "trusted" is a matter of definition (do 155 | you know what you get with "require"?), but at least the code is not 156 | downloaded from the web through an ad or a random web page. 157 | 158 | 159 | ## The hardware problem 160 | 161 | The timing attacks are made possibly by what can only be described as 162 | hardware bugs: 163 | 164 | - Rowhammer is ultimately caused by a combination of DDR3 memory 165 | weaknesses coupled with aggressive (ie low) BIOS DRAM refresh rates. 166 | (Later also demonstrated on some DDR4 memory.) 167 | - Cache sniffing is arguably a problem with shared caches, a problem 168 | that is far from new but has now moved to the L3 cache in 169 | virtualized environments. (Later also demonstrated on some L1 caches.) 170 | 171 | Rowhammer is being addressed by adjusting the BIOS refresh rates (with a performance penalty) and 172 | by more resilient memory types. Cache sniffing is being addressed by 173 | cache partitioning (though it's unclear how good current attempts 174 | are). 175 | 176 | In the past, the cost of denormal floating-point operations has been 177 | used for information stealing with SVG filters, an attack that has 178 | been mitigated by changing timer resolution in the browsers but also 179 | by the CPU manufacturers addressing denormal timing (to some extent), 180 | or by having the hardware flush subnormals to zero. 181 | 182 | As time goes by, the hardware problems are mitigated, and new ones are 183 | introduced, eg, GPUs now support denormals, but they implement 184 | operations on denormals in microcode, making them useful timing 185 | channels. 186 | 187 | We should not let "the hardware problem" be a reason not to take the 188 | attacks seriously, but worrying about one particular type of clock, 189 | some particular hardware issues, and how they combine to enable these 190 | particular side channel leaks feels like a fairly narrow point of 191 | view. Other clocks and other hardware bugs will be found. (An 192 | experiment shows that a counting clock made from the 5μs timer can get 193 | pretty reliable 1μs resolution.) The problem is less the specific 194 | nature of these side channels than that sensitive computations are not 195 | properly insulated from the rest of the system. Admittedly, insulation 196 | often requires hardware and OS changes and not merely careful coding, 197 | but it is still where the actual problem is. 198 | 199 | ## References 200 | 201 | [1] [Yossef Oren et al, "The Spy in the Sandbox -- Practical Cache Attacks in Javascript"](http://arxiv.org/abs/1502.07373v2) 202 | 203 | [2] [Daniel Gruss et al, "Rowhammer.js: A Remote Software-Induced Fault Attack in JavaScript"](http://arxiv.org/abs/1507.06955v1) 204 | 205 | [3] [Paul Stone, "Pixel perfect timing attacks with HTML5"](http://contextis.co.uk/research/white-papers/pixel-perfect-timing-attacks-html5) 206 | 207 | [4] [Marc Andrysco et al, "On Submornal Floating point and abnormal timing](https://cseweb.ucsd.edu/~dkohlbre/papers/subnormal.pdf) 208 | 209 | [5] [Dag Arne Osvik et al, "Cache Attacks and Countermeasures: the Case of AES"](https://eprint.iacr.org/2005/271.pdf) 210 | 211 | [6] [Mehmet Sinan Inci et al, "Seriously, get off my cloud! Cross-VM RSA Key Recovery in a Public Cloud"](https://eprint.iacr.org/2015/898.pdf) 212 | 213 | [7] [Tor project: "High-precision timestamps in JS"](https://trac.torproject.org/projects/tor/ticket/17412) 214 | 215 | [8] [Moritz Lipp et al, "ARMageddon: Last-Level Cache Attacks on Mobile Devices"](http://arxiv.org/abs/1511.04897) 216 | 217 | [9] [Daniel Gruss et al, "Flush+Flush: A Fast and Stealthy Cache Attack"](http://arxiv.org/abs/1511.04594) 218 | -------------------------------------------------------------------------------- /issues/WhyNotJustAsmOrWasm.md: -------------------------------------------------------------------------------- 1 | (Raw notes, need cleanup.) 2 | 3 | Some tasks are best / only done in ES callouts 4 | Input and output, DOM access 5 | “Runtime” tasks 6 | 7 | Copy-in/copy-out at boundary too slow (WebGL) 8 | Thus ES wants some shmem access 9 | 10 | Also asm.js (= ES) can't polyfill for wasm 11 | 12 | Multicore computation in ES is valuable 13 | 14 | ES is the better language (GC, rich types) 15 | 16 | “wasm-only” does not remove races: 17 | ES can call wasm 18 | wasm can export racy accessor functions -------------------------------------------------------------------------------- /tc39/README.md: -------------------------------------------------------------------------------- 1 | spec.html is processed using ecmarkup into shmem.html, which is the 2 | final formatted spec. 3 | 4 | ecmarkup is available here: https://github.com/bterlson/ecmarkup. 5 | 6 | ecmarkup requires io.js, available here: https://iojs.org/en/index.html. 7 | 8 | ACKNOWLEDGEMENTS: The SIMD.js spec was very helpful in formatting the 9 | shared memory spec, see https://github.com/johnmccutchan/ecmascript_simd. 10 | -------------------------------------------------------------------------------- /tc39/agents-mar-2016.odp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/tc39/proposal-ecmascript-sharedmem/55dfee88564e075a68b98ff4116121f6161953f4/tc39/agents-mar-2016.odp -------------------------------------------------------------------------------- /tc39/agents-mar-2016.pdf: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/tc39/proposal-ecmascript-sharedmem/55dfee88564e075a68b98ff4116121f6161953f4/tc39/agents-mar-2016.pdf -------------------------------------------------------------------------------- /tc39/clippings.html: -------------------------------------------------------------------------------- 1 |FIXME: This may not adequately specify global synchronization. It may be an error to attempt to operationalize this. But it's important to specify that overlapping but non-indentical atomic accesses to the same locations may actually be racy.
5 | 6 |MemoryLock communicates with other agents.
17 |Atomicity is only guaranteed for same-sized accesses to the same memory locations, hence the attempt above at operationalizing that. But that may be a mistake.
21 |MemoryUnlock communicates with other agents.
34 |FIXME: It's possible that the shared-memory case should be embedded in GetValueFromBuffer and SetValueInBuffer, since the latter have callers elsewhere.
45 |Replace 14 with the following algorithm:
48 |Replace step 16 with the following algorithm:
59 |This is the same as ArrayBuffer's GetValueFromBuffer (ES6 24.1.1.5) except that:
73 |This is the same as ArrayBuffer's SetValueInBuffer (ES6 24.1.1.6) except that:
84 |There is a relation happens-before on program steps that is defined as follows.
99 |A step in the algorithms below that is marked "With atomic access to ..." is known as an atomic step. There must be a single total order (shared by all the agents that are able to communicate through shared memory) in which atomic steps occur, known as the atomics order. If an atomic step R reads some bytes B0 through Bn in a SharedArrayBuffer, for each byte B it may return any of:
110 |Notes:
117 |If the two threads access the same shared memory cells , and at least one access is not an atomic operation 125 |
Atomic accesses to memory are totally ordered.
126 | 127 | 128 | 137 | 138 |This is the same operation as Atomics.load, but where the observable memory effects of Atomics.load relative to operations before and after it are defined, Atomics.loadUnordered can be rearranged (in terms of memory effects) with unordered operations that precede or succeed it, including non-atomic operations. Atomics.loadUnordered can be implemented much more efficiently than Atomics.load on almost all platforms.
142 |This is the same operation as Atomics.store, but where the observable memory effects of Atomics.store relative to operations before and after it are defined, Atomics.storeUnordered can be rearranged (in terms of memory effects) with unordered operations that precede or succeed it, including non-atomic operations. Atomics.storeUnordered can be implemented much more efficiently than Atomics.store on almost all platforms.
149 |This tests whether a ServiceWorker can receive and send shared 11 | memory objects. Whether it should be able to do so depends on the 12 | embedding.
13 | 14 |Output will appear below. In addition to informational and "OK" lines there are lines about exceptions and errors. Two forms of output are expected: 15 | 16 |
For any other type of output, consult the code.
22 | 23 | 24 | 25 | 32 | 33 | 34 | 35 | 36 | 37 | -------------------------------------------------------------------------------- /test-html/futexInterrupt-worker.js: -------------------------------------------------------------------------------- 1 | importScripts("worker-harness.js"); 2 | 3 | onmessage = 4 | function (ev) { 5 | var iab = new Int32Array(ev.data); 6 | Atomics.wait(iab, 0, 0, Number.POSITIVE_INFINITY); 7 | postMessage("THIS SHOULD NOT HAPPEN"); 8 | }; 9 | -------------------------------------------------------------------------------- /test-html/futexMainWakeup-worker.js: -------------------------------------------------------------------------------- 1 | importScripts("worker-harness.js"); 2 | 3 | var mem; 4 | 5 | onmessage = function (ev) { 6 | switch (ev.data[0]) { 7 | case "start": 8 | mem = new Int32Array(ev.data[1]); 9 | break; 10 | case "run": 11 | setTimeout(function () { 12 | postMessage("Worker: Waking it up now"); 13 | Atomics.wake(mem, 0, 1) 14 | }, ev.data[1]); 15 | break; 16 | } 17 | } 18 | -------------------------------------------------------------------------------- /test-html/futexTimeout_slave.js: -------------------------------------------------------------------------------- 1 | importScripts("worker-harness.js"); 2 | 3 | var mem; 4 | var WAITLOC; 5 | 6 | onmessage = 7 | function (ev) { 8 | try { 9 | switch (ev.data[0]) { 10 | case "start": 11 | mem = new Int32Array(ev.data[1]); 12 | WAITLOC = ev.data[2]; 13 | break; 14 | case "timeout": 15 | var [_, ms, result] = ev.data; 16 | postMessage(["msg", "Going into " + ms + "ms wait in the worker"]); 17 | var t0 = Date.now(); 18 | var r = Atomics.wait(mem, WAITLOC, 0, ms); 19 | postMessage(["msg", "Wait returned " + r]); 20 | var t1 = Date.now(); 21 | switch (r) { 22 | case "timed-out": 23 | case "not-equal": 24 | case "ok": 25 | postMessage([r, result, t1-t0]); 26 | break; 27 | default: 28 | postMessage(["failure", [result, r], t1-t0]); 29 | break; 30 | } 31 | break; 32 | default: 33 | postMessage("Bogus command: " + ev.data.join(",")); 34 | break; 35 | } 36 | } 37 | catch (e) { 38 | postMessage("Caught exception: " + e); 39 | } 40 | }; 41 | 42 | -------------------------------------------------------------------------------- /test-html/futexWakeInInterrupt-worker.js: -------------------------------------------------------------------------------- 1 | importScripts("worker-harness.js"); 2 | 3 | onmessage = function (ev) { 4 | var [sab] = ev.data; 5 | var mem = new Int32Array(sab); 6 | 7 | setTimeout(function () { 8 | Atomics.wake(mem, 0, 1); 9 | }, 20000); 10 | } 11 | -------------------------------------------------------------------------------- /test-html/harness.js: -------------------------------------------------------------------------------- 1 | document.writeln(""); 2 | 3 | function msg(s) { 4 | var d = document.createElement('div'); 5 | d.appendChild(document.createTextNode(s)); 6 | document.getElementById("scrool").appendChild(d); 7 | } 8 | 9 | // The spec allows individual threads to prevent blocking. In a 10 | // browser, this will be an issue only on the main thread. 11 | 12 | var canBlockOnThisThread = (function () { 13 | var mem = new Int32Array(new SharedArrayBuffer(4)); 14 | var didThrow = false; 15 | try { 16 | Atomics.wait(mem, 0, 0, 0); 17 | } 18 | catch (e) { 19 | didThrow = true; 20 | } 21 | return !didThrow; 22 | })(); 23 | -------------------------------------------------------------------------------- /test-html/index.html: -------------------------------------------------------------------------------- 1 | 2 | 3 | 4 | 5 |These test cases run as you load them and test that sharing restrictions are implemented correctly:
10 |These test cases run as you load them and test misc inter-agent functionality:
18 |These test cases require additional interaction to run:
25 |These test cases require the browser or tab to be shut down:
34 |This tests that futexes that are blocked will be interrupted and will 11 | not block the browser when the tab is closed or the browser is shut 12 | down.
13 | 14 |Open this page in the browser. It will create a worker that 15 | blocks indefinitely in Atomics.wait(). No line should appear below that 16 | says "THIS SHOULD NOT HAPPEN".
17 | 18 | 19 | 20 |Now try to close the tab or close the browser! If the code works 21 | as it should, the tab or browser should close; if you close the 22 | browser you should see no trace of the browser process in a process 23 | monitor or similar.
24 | 25 |(Firefox devs: try ./mach run from the command prompt, ideally in a debug build, 26 | since release builds will tend to just exit in a hard way if things get stuck.)
27 | 28 | 34 | 35 | 36 | 37 | -------------------------------------------------------------------------------- /test-html/test_futexMainTimeout.html: -------------------------------------------------------------------------------- 1 | 2 | 3 | 4 | 5 |Tests Atomics.wait timeouts on the main thread.
11 | 12 |Just load the page, click , and leave the browser alone. The main thread will go 14 | to sleep for a few seconds and then time out, you should see some 15 | output below. If you receive the slow-script dialog something is 16 | wrong. 17 | 18 |
Also check the console for errors. 19 | 20 | 21 | 22 | 52 | 53 | 54 | 55 | -------------------------------------------------------------------------------- /test-html/test_futexMainWakeup.html: -------------------------------------------------------------------------------- 1 | 2 | 3 |
4 | 5 |Tests that the main thread can be awoken by a worker.
11 | 12 |Just load the page, click , and leave the browser alone. The main thread will go 14 | to sleep for a few seconds and then be worken by a worker thread, you 15 | should see some output below. If you receive the slow-script dialog 16 | something is wrong. 17 | 18 |
Also check the console for errors. 19 | 20 | 21 | 22 | 44 | 45 | 46 | 47 | -------------------------------------------------------------------------------- /test-html/test_futexSlowscript.html: -------------------------------------------------------------------------------- 1 | 2 | 3 |
4 | 5 |Tests the slow script dialog within a Atomics.wait on the main thread. This may be Firefox-specific at the moment.
11 | 12 |Just load the page, click , and leave the browser alone. The slow script dialog 14 | should appear after a while. You should be able to Continue the 15 | script without anything happening except the dialog appearing again 16 | later. You should be able to Stop the script and have the browser go 17 | back to being its responsive self, without any scary-looking output 18 | appearing below (there will be some output). 19 | 20 |
Remember to beween 21 | each test, when the script is killed 22 | it leaves global status variables in an inconsistent state. 23 | 24 |
Also check the console, once you kill the script there should be a 25 | stack trace there. 26 | 27 |
Try these experiments: 28 |
Additionally you should be able to bring up the script in a debugger by 35 | clicking "Debug script" in the slow-script dialog. (On my system this causes 36 | one of my cores to stay at 100% utilization.) 37 | 38 | 39 | 40 | 63 | 64 | 65 | 66 | -------------------------------------------------------------------------------- /test-html/test_futexTimeout.html: -------------------------------------------------------------------------------- 1 | 2 | 3 |
4 | 5 |Tests Atomics.wait, Atomics.wake, and timeout functionality.
11 | 12 |The tests run when the page is loaded. The output from these 13 | tests will appear below. If everything goes OK it should end with the 14 | line DONE after a while, and there should be no lines that start with 15 | FAIL.
16 | 17 |Also check the console for errors; there should be none.
18 | 19 | 20 | 21 | 225 | 226 | 227 | 228 | -------------------------------------------------------------------------------- /test-html/test_futexWakeInInterrupt.html: -------------------------------------------------------------------------------- 1 | 2 | 3 | 4 | 5 |Firefox note: This test does not work with e10s (process separation) enabled. 11 | 12 |
Just load the page, click , and leave the browser alone. The main thread will go 14 | to sleep for 10-15 seconds and then time out, and you'll see the slow-script dialog. 15 | 16 |
No earlier than 25 seconds after clicking the button originally, 17 | hit the Continue button on the slow-script dialog. The timing is important; don't 18 | click it too early. 19 | 20 |
Immediately after the dialog closes you should see output in the page below. 21 | If you get a second slow-script dialog then something has probably gone wrong. 22 | 23 |
Also check the console for errors. 24 | 25 | 26 | 27 | 53 | 54 | 55 | 56 | -------------------------------------------------------------------------------- /test-html/test_serviceWorkerNotSharing.html: -------------------------------------------------------------------------------- 1 | 2 | 3 | 4 | 5 |
6 | 7 |Tests that shared memory cannot be sent to or from a 12 | ServiceWorker instance.
13 | 14 |This test needs to access the web (it uses HTTPS). It will load 15 | files from 16 | https://lars-t-hansen.github.io/ecmascript_sharedmem/tests/.
17 | 18 |Click 19 | here to load and run the test.
20 | 21 | 22 | 23 | -------------------------------------------------------------------------------- /test-html/test_sharedMemCriticalSection.html: -------------------------------------------------------------------------------- 1 | 2 | 3 | 4 | 5 |This test case tests that mutual exclusion on SharedArrayBuffer 10 | using Atomics operations works.
11 | 12 |The test runs when you load the page. It usually takes 1-5 13 | seconds and the output appears below. There should be no error 14 | messages and finally a line that says SUCCESS (there may be even more 15 | output after that). Also check the browser console for errors, there should 16 | be none.
17 | 18 | 19 | 20 | 34 | 35 | 36 | -------------------------------------------------------------------------------- /test-html/test_sharedTypedArrayClone.html: -------------------------------------------------------------------------------- 1 | 2 | 3 | 4 | 5 |This tests that SharedArrayBuffer and SharedInt32Array values can be 11 | transmitted to a worker.
12 | 13 |The test runs when you load the page. Look for "DONE" below this 14 | paragraph. There will be other lines but there should be no error 15 | messages in the output or in the browser console.
16 | 17 | 18 | 19 | 42 | 43 | 44 | 45 | -------------------------------------------------------------------------------- /test-html/test_sharing_sharedworker_and_nested_worker.html: -------------------------------------------------------------------------------- 1 | 2 | 3 | 4 | 5 |This test case tests that sharing memory by postMessage between a 11 | SharedWorker and its nested Worker works in both directions.
12 | 13 |The test runs when you load the page. It usually takes little 14 | time and the output appears below. There should be no error messages 15 | and finally a line that says SUCCESS (there may be even more output 16 | after that). Also check the browser console for errors, there should 17 | be none.
18 | 19 | 20 | 21 | 32 | 33 | 34 | -------------------------------------------------------------------------------- /test-html/test_sharing_window_and_sharedworker.html: -------------------------------------------------------------------------------- 1 | 2 | 3 | 4 | 5 |This test case tests that sharing memory by postMessage between a 10 | Window and its SharedWorker does not work in either direction.
11 | 12 |If everything goes OK there should be no lines below saying 13 | "SHOULD NOT HAPPEN", and instead there should be lines saying 14 | "SUCCESS - Failed to send".
15 | 16 |Also check the console, there should be nothing unusual there.
17 | 18 |19 | 20 |21 | 22 | 23 | 24 | 25 | 26 | -------------------------------------------------------------------------------- /test-html/test_sharing_window_and_worker.html: -------------------------------------------------------------------------------- 1 | 2 | 3 | 4 | 5 |
This test case tests that sharing memory by postMessage between a 10 | Window and its Worker works in both directions.
11 | 12 |The test runs when you load the page. It usually takes little 13 | time and the output appears below. There should be no error messages 14 | and finally a line that says SUCCESS (there may be even more output 15 | after that). Also check the browser console for errors, there should 16 | be none.
17 | 18 | 19 | 20 | 32 | 33 | 34 | -------------------------------------------------------------------------------- /test-html/test_sharing_worker_and_nested_worker.html: -------------------------------------------------------------------------------- 1 | 2 | 3 | 4 | 5 |This test case tests that sharing memory by postMessage between a 11 | Worker and its nested Worker works in both directions.
12 | 13 |The test runs when you load the page. It usually takes little 14 | time and the output appears below. There should be no error messages 15 | and finally a line that says SUCCESS (there may be even more output 16 | after that). Also check the browser console for errors, there should 17 | be none.
18 | 19 | 20 | 21 | 33 | 34 | 35 | -------------------------------------------------------------------------------- /test-html/worker-harness.js: -------------------------------------------------------------------------------- 1 | /* Empty, for now */ 2 | -------------------------------------------------------------------------------- /test262/LICENSE.md: -------------------------------------------------------------------------------- 1 | The intended license for the test262/ subdirectory of the 2 | ecmacript_sharedmem repository is the BSD license. 3 | -------------------------------------------------------------------------------- /test262/README.md: -------------------------------------------------------------------------------- 1 | These are test cases that should be largely compatible with the 2 | test262 framework, only minor editing should be necessary to 3 | incorporate them into the test262 test suite later. 4 | 5 | At the moment, these test cases use their own test runner and harness 6 | however, and each incorporates a little prologue and epilogue that 7 | will later be removed. 8 | 9 | In a browser, load runner.html to run all the tests. 10 | 11 | In a JS shell, run each test case by first loading harness.js and then 12 | the test case. 13 | -------------------------------------------------------------------------------- /test262/agenttest_spidermonkey.js: -------------------------------------------------------------------------------- 1 | // Copyright (C) 2015 Mozilla Corporation. All rights reserved. 2 | // This code is governed by the BSD license found in the LICENSE file. 3 | // 4 | 5 | // AgentTest infrastructure for JS shells. Load this as a prefix to 6 | // tests that need to run in multiple agents. 7 | // 8 | // (This implementation for the SpiderMonkey shell.) 9 | // 10 | // 11 | // In the main thread, there is an object AgentTest: 12 | // 13 | // AgentTest.start(script_source) => void 14 | // Run the `script_source` program in a concurrent agent. 15 | // Blocks until that agent is up and running. 16 | // 17 | // AgentTest.broadcast(id, sab) => void 18 | // Send the pair {id, sab} to all concurrent agents. `id` will be 19 | // coerced to Int32. `sab` must be a SharedArrayBuffer. Blocks 20 | // until all the agents have acknowedged receipt of the message. 21 | // 22 | // Note, broadcast assumes all agents that were started are still 23 | // alive and will deadlock if any have terminated. 24 | // 25 | // AgentTest.getReport() => string | null 26 | // Probe for a text message from any agent, return null if none is 27 | // available. Will not block. 28 | // 29 | // AgentTest.sleep(ms) 30 | // Wait for `ms` milliseconds. 31 | // 32 | // AgentTest.reset() 33 | // All concurrent agents should have exited - this will be assumed, 34 | // not checked! Reinitialize global state for a new round of tests. 35 | // 36 | // 37 | // In the concurrent agent, there is also an object AgentTest: 38 | // 39 | // AgentTest.receive() 40 | // Block until a {sab, id} pair is broadcast from the master, then 41 | // return it. 42 | // 43 | // AgentTest.report(string) 44 | // Report the string back to the master, will not block. Messages 45 | // should be short and sweet, as there is fixed, limited space. 46 | // 47 | // AgentTest.sleep(ms) 48 | // Wait for `ms` milliseconds. 49 | // 50 | // AgentTest.leaving() 51 | // The agent is about to terminate. (This will not be called if the 52 | // agent crashes and is here as a portable hook to make the agent 53 | // terminate itself, should it need to.) 54 | 55 | // ------------------------------------------------------------ 56 | 57 | // The SpiderMonkey implementation uses a designated shared buffer _ia 58 | // for coordination, and spinlocks for everything except sleeping. 59 | 60 | var _MSG_LOC = 0; // Low bit set: broadcast available; High bits: seq # 61 | var _ID_LOC = 1; // ID sent with broadcast 62 | var _ACK_LOC = 2; // Worker increments this to ack that broadcast was received 63 | var _RDY_LOC = 3; // Worker increments this to ack that worker is up and running 64 | var _LOCKTXT_LOC = 4; // Writer lock for the text buffer: 0=open, 1=closed 65 | var _NUMTXT_LOC = 5; // Count of messages in text buffer 66 | var _NEXT_LOC = 6; // First free location in the buffer 67 | var _SLEEP_LOC = 7; // Used for sleeping 68 | 69 | var _FIRST = 10; // First location of first message 70 | 71 | var _ia = new Int32Array(new SharedArrayBuffer(65536)); 72 | _ia[_NEXT_LOC] = _FIRST; 73 | 74 | // AgentTest object in the agent, prepended to the agent's source. 75 | 76 | var _worker_AgentTest = ` 77 | var AgentTest = 78 | { 79 | receive: function() { 80 | var k; 81 | while (((k = Atomics.load(_ia, ${_MSG_LOC})) & 1) == 0) 82 | ; 83 | var received_sab = getSharedArrayBuffer(); 84 | var received_id = Atomics.load(_ia, ${_ID_LOC}); 85 | Atomics.add(_ia, ${_ACK_LOC}, 1); 86 | while (Atomics.load(_ia, ${_MSG_LOC}) == k) 87 | ; 88 | return { id: received_id, sab: received_sab }; 89 | }, 90 | 91 | report: function(msg) { 92 | while (Atomics.compareExchange(_ia, ${_LOCKTXT_LOC}, 0, 1) == 1) 93 | ; 94 | msg = "" + msg; 95 | var i = _ia[${_NEXT_LOC}]; 96 | _ia[i++] = msg.length; 97 | for ( let j=0 ; j < msg.length ; j++ ) 98 | _ia[i++] = msg.charCodeAt(j); 99 | _ia[${_NEXT_LOC}] = i; 100 | Atomics.add(_ia, ${_NUMTXT_LOC}, 1); 101 | Atomics.store(_ia, ${_LOCKTXT_LOC}, 0); 102 | }, 103 | 104 | sleep: function(s) { 105 | Atomics.wait(_ia, ${_SLEEP_LOC}, 0, s); 106 | }, 107 | 108 | leaving: function() {} 109 | } 110 | var _ia = new Int32Array(getSharedArrayBuffer()); 111 | Atomics.add(_ia, ${_RDY_LOC}, 1); 112 | `; 113 | 114 | // AgentTest object in the main thread. 115 | 116 | var AgentTest = 117 | { 118 | _numWorkers: 0, 119 | _numReports: 0, 120 | _reportPtr: _FIRST, 121 | 122 | start: function (script) { 123 | setSharedArrayBuffer(_ia.buffer); 124 | var oldrdy = Atomics.load(_ia, _RDY_LOC); 125 | evalInWorker(_worker_AgentTest + script); 126 | while (Atomics.load(_ia, _RDY_LOC) == oldrdy) 127 | ; 128 | this._numWorkers++; 129 | }, 130 | 131 | broadcast: function (sab, id) { 132 | setSharedArrayBuffer(sab); 133 | Atomics.store(_ia, _ID_LOC, id); 134 | Atomics.store(_ia, _ACK_LOC, 0); 135 | Atomics.add(_ia, _MSG_LOC, 1); 136 | while (Atomics.load(_ia, _ACK_LOC) < this._numWorkers) 137 | ; 138 | Atomics.add(_ia, _MSG_LOC, 1); 139 | }, 140 | 141 | getReport: function () { 142 | if (this._numReports == Atomics.load(_ia, _NUMTXT_LOC)) 143 | return null; 144 | var s = ""; 145 | var i = this._reportPtr; 146 | var len = _ia[i++]; 147 | for ( let j=0 ; j < len ; j++ ) 148 | s += String.fromCharCode(_ia[i++]); 149 | this._reportPtr = i; 150 | this._numReports++; 151 | return s; 152 | }, 153 | 154 | sleep: function(s) { 155 | Atomics.wait(_ia, _SLEEP_LOC, 0, s); 156 | }, 157 | 158 | reset: function() { 159 | this._numWorkers = 0; 160 | this._numReports = 0; 161 | this._reportPtr = _FIRST; 162 | _ia[_MSG_LOC] = 0; 163 | _ia[_ID_LOC] = 0; 164 | _ia[_ACK_LOC] = 0; 165 | _ia[_RDY_LOC] = 0; 166 | _ia[_LOCKTXT_LOC] = 0; 167 | _ia[_NUMTXT_LOC] = 0; 168 | _ia[_NEXT_LOC] = _FIRST; 169 | } 170 | } 171 | -------------------------------------------------------------------------------- /test262/atomics-on-good-arrays.js: -------------------------------------------------------------------------------- 1 | // Copyright (C) 2015 Mozilla Corporation. All rights reserved. 2 | // This code is governed by the BSD license found in the LICENSE file. 3 | 4 | // BEGIN PROLOGUE 5 | beginTest("atomics-on-good-arrays"); 6 | // END PROLOGUE 7 | 8 | /*--- 9 | es7id: TBD 10 | description: > 11 | Test atomic operations on arrays that allow atomic operations 12 | ---*/ 13 | 14 | var sab = new SharedArrayBuffer(1024); 15 | var ab = new ArrayBuffer(16); 16 | 17 | var int_views = [Int8Array, Uint8Array, Int16Array, Uint16Array, Int32Array, Uint32Array]; 18 | 19 | for ( var idx=0 ; idx < int_views.length ; idx++ ) { 20 | var View = int_views[idx]; 21 | 22 | // Make it interesting - use non-zero byteOffsets and non-zero indexes 23 | 24 | var view = new View(sab, 32, 20); 25 | 26 | assert.sameValue(Atomics.store(view, 3, 10), 10); 27 | assert.sameValue(Atomics.load(view, 3), 10); 28 | assert.sameValue(Atomics.exchange(view, 3, 5), 10); 29 | assert.sameValue(Atomics.load(view, 3), 5); 30 | assert.sameValue(Atomics.compareExchange(view, 3, 5, 8), 5); 31 | assert.sameValue(Atomics.load(view, 3), 8); 32 | assert.sameValue(Atomics.compareExchange(view, 3, 5, 16), 8); 33 | assert.sameValue(Atomics.load(view, 3), 8); 34 | 35 | assert.sameValue(Atomics.add(view, 8, 10), 0); // 0 + 10 -> 10 36 | assert.sameValue(Atomics.sub(view, 8, 5), 10); // 10 - 5 -> 5 37 | assert.sameValue(Atomics.and(view, 8, 3), 5); // 5 & 3 -> 1 38 | assert.sameValue(Atomics.or(view, 8, 6), 1); // 1 | 6 -> 7 39 | assert.sameValue(Atomics.xor(view, 8, 2), 7); // 7 ^ 2 -> 5 40 | assert.sameValue(Atomics.load(view, 8), 5); // 5 41 | 42 | // Rudimentary tests for sign extension and chopping. 43 | 44 | var control = new View(ab, 0, 2); 45 | var r; 46 | 47 | r = Atomics.store(view, 3, -5); control[0] = -5; 48 | assert.sameValue(r, -5); 49 | assert.sameValue(Atomics.load(view, 3), control[0]); 50 | assert.sameValue(Atomics.exchange(view, 3, 0), control[0]); 51 | view[3] = -5; 52 | assert.sameValue(Atomics.add(view, 3, 0), control[0]); 53 | assert.sameValue(Atomics.sub(view, 3, 0), control[0]); 54 | assert.sameValue(Atomics.and(view, 3, -1), control[0]); 55 | assert.sameValue(Atomics.or(view, 3, 0), control[0]); 56 | assert.sameValue(Atomics.xor(view, 3, 0), control[0]); 57 | control[1] = -7; 58 | assert.sameValue(Atomics.compareExchange(view, 3, control[0], -7), control[0]); 59 | assert.sameValue(Atomics.compareExchange(view, 3, control[0], -9), control[1]); 60 | assert.sameValue(view[3], control[1]); 61 | 62 | r = Atomics.store(view, 3, 12345); control[0] = 12345; 63 | assert.sameValue(r, 12345); 64 | assert.sameValue(Atomics.load(view, 3), control[0]); 65 | assert.sameValue(Atomics.exchange(view, 3, 0), control[0]); 66 | view[3] = 12345; 67 | assert.sameValue(Atomics.add(view, 3, 0), control[0]); 68 | assert.sameValue(Atomics.sub(view, 3, 0), control[0]); 69 | assert.sameValue(Atomics.and(view, 3, -1), control[0]); 70 | assert.sameValue(Atomics.or(view, 3, 0), control[0]); 71 | assert.sameValue(Atomics.xor(view, 3, 0), control[0]); 72 | control[1] = 23456; 73 | assert.sameValue(Atomics.compareExchange(view, 3, control[0], 23456), control[0]); 74 | assert.sameValue(Atomics.compareExchange(view, 3, control[0], 34567), control[1]); 75 | assert.sameValue(view[3], control[1]); 76 | 77 | r = Atomics.store(view, 3, 123456789); control[0] = 123456789; 78 | assert.sameValue(r, 123456789); 79 | assert.sameValue(Atomics.load(view, 3), control[0]); 80 | assert.sameValue(Atomics.exchange(view, 3, 0), control[0]); 81 | view[3] = 123456789; 82 | assert.sameValue(Atomics.add(view, 3, 0), control[0]); 83 | assert.sameValue(Atomics.sub(view, 3, 0), control[0]); 84 | assert.sameValue(Atomics.and(view, 3, -1), control[0]); 85 | assert.sameValue(Atomics.or(view, 3, 0), control[0]); 86 | assert.sameValue(Atomics.xor(view, 3, 0), control[0]); 87 | control[1] = 234567890; 88 | assert.sameValue(Atomics.compareExchange(view, 3, control[0], 234567890), control[0]); 89 | assert.sameValue(Atomics.compareExchange(view, 3, control[0], 345678901), control[1]); 90 | assert.sameValue(view[3], control[1]); 91 | 92 | r = Atomics.store(view, 3, Math.PI); control[0] = Math.PI; 93 | assert.sameValue(r, Math.PI); 94 | assert.sameValue(Atomics.load(view, 3), control[0]); 95 | assert.sameValue(Atomics.exchange(view, 3, 0), control[0]); 96 | 97 | // Do not affect memory outside the elements written. 98 | 99 | for ( var i=0 ; i < view.length ; i++ ) { 100 | if (i == 3 || i == 8) 101 | continue; 102 | assert.sameValue(view[i], 0); 103 | } 104 | 105 | view[3] = 0; 106 | view[8] = 0; 107 | } 108 | 109 | // BEGIN EPILOGUE 110 | finishTest("atomics-on-good-arrays"); 111 | // END EPILOGUE 112 | -------------------------------------------------------------------------------- /test262/atomics-on-nonshared-int-arrays.js: -------------------------------------------------------------------------------- 1 | // Copyright (C) 2015 Mozilla Corporation. All rights reserved. 2 | // This code is governed by the BSD license found in the LICENSE file. 3 | 4 | // BEGIN PROLOGUE 5 | beginTest("atomics-on-nonshared-int-arrays"); 6 | // END PROLOGUE 7 | 8 | /*--- 9 | es7id: TBD 10 | description: > 11 | Test atomic operations on non-shared integer TypedArrays 12 | ---*/ 13 | 14 | var ab = new ArrayBuffer(16); 15 | 16 | var int_views = [Int8Array, Uint8Array, Int16Array, Uint16Array, Int32Array, Uint32Array]; 17 | 18 | for ( var View of int_views ) { 19 | var view = new View(ab); 20 | 21 | assert.throws(TypeError, (() => Atomics.load(view, 0))); 22 | assert.throws(TypeError, (() => Atomics.store(view, 0, 0))); 23 | assert.throws(TypeError, (() => Atomics.exchange(view, 0, 0))); 24 | assert.throws(TypeError, (() => Atomics.compareExchange(view, 0, 0, 0))); 25 | assert.throws(TypeError, (() => Atomics.add(view, 0, 0))); 26 | assert.throws(TypeError, (() => Atomics.sub(view, 0, 0))); 27 | assert.throws(TypeError, (() => Atomics.and(view, 0, 0))); 28 | assert.throws(TypeError, (() => Atomics.or(view, 0, 0))); 29 | assert.throws(TypeError, (() => Atomics.xor(view, 0, 0))); 30 | } 31 | 32 | // BEGIN EPILOGUE 33 | finishTest("atomics-on-nonshared-int-arrays"); 34 | // END EPILOGUE 35 | -------------------------------------------------------------------------------- /test262/atomics-on-other-stuff.js: -------------------------------------------------------------------------------- 1 | // Copyright (C) 2015 Mozilla Corporation. All rights reserved. 2 | // This code is governed by the BSD license found in the LICENSE file. 3 | 4 | // BEGIN PROLOGUE 5 | beginTest("atomics-on-other-stuff"); 6 | // END PROLOGUE 7 | 8 | /*--- 9 | es7id: TBD 10 | description: > 11 | Test atomic operations on values other than TypedArrays 12 | ---*/ 13 | 14 | var values = [null, 15 | undefined, 16 | true, 17 | false, 18 | new Boolean(true), 19 | 10, 20 | 3.14, 21 | new Number(4), 22 | "Hi there", 23 | new Date, 24 | /a*utomaton/g, 25 | { password: "qumquat" }, 26 | new DataView(new ArrayBuffer(10)), 27 | new ArrayBuffer(128), 28 | new SharedArrayBuffer(128), 29 | new Error("Ouch"), 30 | [1,1,2,3,5,8], 31 | ((x) => -x), 32 | new Map(), 33 | new Set(), 34 | new WeakMap(), 35 | new WeakSet(), 36 | this.Promise ? new Promise(() => "done") : undefined, 37 | Symbol("halleluja"), 38 | // TODO: Proxy? 39 | Object, 40 | Int32Array, 41 | Date, 42 | Math, 43 | Atomics ]; 44 | 45 | for ( var i=0 ; i < values.length ; i++ ) { 46 | var view = values[i]; 47 | assert.throws(TypeError, (() => Atomics.load(view, 0))); 48 | assert.throws(TypeError, (() => Atomics.store(view, 0, 0))); 49 | assert.throws(TypeError, (() => Atomics.exchange(view, 0, 0))); 50 | assert.throws(TypeError, (() => Atomics.compareExchange(view, 0, 0, 0))); 51 | assert.throws(TypeError, (() => Atomics.add(view, 0, 0))); 52 | assert.throws(TypeError, (() => Atomics.sub(view, 0, 0))); 53 | assert.throws(TypeError, (() => Atomics.and(view, 0, 0))); 54 | assert.throws(TypeError, (() => Atomics.or(view, 0, 0))); 55 | assert.throws(TypeError, (() => Atomics.xor(view, 0, 0))); 56 | assert.throws(TypeError, (() => Atomics.wait(view, 0, 0))); 57 | assert.throws(TypeError, (() => Atomics.wake(view, 0))); 58 | } 59 | 60 | // BEGIN EPILOGUE 61 | finishTest("atomics-on-other-stuff"); 62 | // END EPILOGUE 63 | -------------------------------------------------------------------------------- /test262/atomics-on-shared-nonint-arrays.js: -------------------------------------------------------------------------------- 1 | // Copyright (C) 2015 Mozilla Corporation. All rights reserved. 2 | // This code is governed by the BSD license found in the LICENSE file. 3 | 4 | // BEGIN PROLOGUE 5 | beginTest("atomics-on-shared-nonint-arrays"); 6 | // END PROLOGUE 7 | 8 | /*--- 9 | es7id: TBD 10 | description: > 11 | Test atomic operations on shared non-integer TypedArrays 12 | ---*/ 13 | 14 | var sab = new SharedArrayBuffer(1024); 15 | 16 | var other_views = [Uint8ClampedArray, Float32Array, Float64Array]; 17 | 18 | for ( var View of other_views ) { 19 | var view = new View(sab); 20 | 21 | assert.throws(TypeError, (() => Atomics.load(view, 0))); 22 | assert.throws(TypeError, (() => Atomics.store(view, 0, 0))); 23 | assert.throws(TypeError, (() => Atomics.exchange(view, 0, 0))); 24 | assert.throws(TypeError, (() => Atomics.compareExchange(view, 0, 0, 0))); 25 | assert.throws(TypeError, (() => Atomics.add(view, 0, 0))); 26 | assert.throws(TypeError, (() => Atomics.sub(view, 0, 0))); 27 | assert.throws(TypeError, (() => Atomics.and(view, 0, 0))); 28 | assert.throws(TypeError, (() => Atomics.or(view, 0, 0))); 29 | assert.throws(TypeError, (() => Atomics.xor(view, 0, 0))); 30 | assert.throws(TypeError, (() => Atomics.wait(view, 0, 0))); 31 | assert.throws(TypeError, (() => Atomics.wake(view, 0))); 32 | } 33 | 34 | // BEGIN EPILOGUE 35 | finishTest("atomics-on-shared-nonint-arrays"); 36 | // END EPILOGUE 37 | -------------------------------------------------------------------------------- /test262/atomics-range.js: -------------------------------------------------------------------------------- 1 | // Copyright (C) 2015 Mozilla Corporation. All rights reserved. 2 | // This code is governed by the BSD license found in the LICENSE file. 3 | 4 | // BEGIN PROLOGUE 5 | beginTest("atomics-range"); 6 | // END PROLOGUE 7 | 8 | /*--- 9 | es7id: TBD 10 | description: > 11 | Test range checking of atomic operations (on arrays that allow atomic operations) 12 | ---*/ 13 | 14 | var sab = new SharedArrayBuffer(4); 15 | 16 | var views = [Int8Array, Uint8Array, Int16Array, Uint16Array, Int32Array, Uint32Array]; 17 | 18 | var bad_indices = [ (view) => -1, 19 | (view) => view.length, 20 | (view) => view.length*2, 21 | (view) => undefined, 22 | (view) => Number.NaN, 23 | (view) => Number.POSITIVE_INFINITY, 24 | (view) => Number.NEGATIVE_INFINITY, 25 | (view) => '3.5', 26 | (view) => 3.5, 27 | (view) => { password: "qumquat" }, 28 | (view) => ({ valueOf: () => 125 }), 29 | (view) => ({ toString: () => '125', valueOf: false }) // non-callable valueOf triggers invocation of toString 30 | ]; 31 | 32 | for ( var vidx=0 ; vidx < views.length ; vidx++ ) { 33 | var View = views[vidx]; 34 | var view = new View(sab); 35 | 36 | for ( var iidx=0 ; iidx < bad_indices.length ; iidx++ ) { 37 | var Idx = bad_indices[iidx](view); 38 | assert.throws(RangeError, () => Atomics.store(view, Idx, 10)); 39 | assert.throws(RangeError, () => Atomics.load(view, Idx)); 40 | assert.throws(RangeError, () => Atomics.exchange(view, Idx, 5)); 41 | assert.throws(RangeError, () => Atomics.compareExchange(view, Idx, 5, 8)); 42 | assert.throws(RangeError, () => Atomics.add(view, Idx, 10)); 43 | assert.throws(RangeError, () => Atomics.sub(view, Idx, 5)); 44 | assert.throws(RangeError, () => Atomics.and(view, Idx, 3)); 45 | assert.throws(RangeError, () => Atomics.or(view, Idx, 6)); 46 | assert.throws(RangeError, () => Atomics.xor(view, Idx, 2)); 47 | } 48 | } 49 | 50 | var good_indices = [ (view) => 0/-1, // -0 51 | (view) => '-0', 52 | (view) => view.length - 1, 53 | (view) => ({ valueOf: () => 0 }), 54 | (view) => ({ toString: () => '0', valueOf: false }) // non-callable valueOf triggers invocation of toString 55 | ]; 56 | 57 | for ( var vidx=0 ; vidx < views.length ; vidx++ ) { 58 | var View = views[vidx]; 59 | var view = new View(sab); 60 | 61 | for ( var iidx=0 ; iidx < good_indices.length ; iidx++ ) { 62 | var Idx = good_indices[iidx](view); 63 | Atomics.store(view, Idx, 37); 64 | assert.sameValue(Atomics.load(view, Idx), 37); 65 | assert.sameValue(Atomics.exchange(view, Idx, 37), 37); 66 | assert.sameValue(Atomics.compareExchange(view, Idx, 37, 37), 37); 67 | assert.sameValue(Atomics.add(view, Idx, 0), 37); 68 | assert.sameValue(Atomics.sub(view, Idx, 0), 37); 69 | assert.sameValue(Atomics.and(view, Idx, -1), 37); 70 | assert.sameValue(Atomics.or(view, Idx, 0), 37); 71 | assert.sameValue(Atomics.xor(view, Idx, 0), 37); 72 | } 73 | } 74 | 75 | // BEGIN EPILOGUE 76 | finishTest("atomics-range"); 77 | // END EPILOGUE 78 | -------------------------------------------------------------------------------- /test262/dataview-props.js: -------------------------------------------------------------------------------- 1 | // Copyright (C) 2015 Mozilla Corporation. All rights reserved. 2 | // This code is governed by the BSD license found in the LICENSE file. 3 | 4 | // BEGIN PROLOGUE 5 | beginTest("dataview-props"); 6 | // END PROLOGUE 7 | 8 | /*--- 9 | es7id: TBD 10 | description: > 11 | Test the properties of DataView views on shared memory 12 | ---*/ 13 | 14 | var sab = new SharedArrayBuffer(1024); 15 | 16 | // Create DataView on SharedArrayBuffer 17 | 18 | var view = new DataView(sab); 19 | 20 | assert.sameValue(view.buffer, sab); 21 | assert.sameValue(view.byteLength, sab.byteLength); 22 | assert.sameValue(view.byteOffset, 0); 23 | 24 | var u8 = new Uint8Array(sab); 25 | 26 | u8[1] = 1; 27 | u8[2] = 2; 28 | 29 | // Read value from DataView on SharedArrayBuffer 30 | 31 | assert.sameValue(view.getUint16(1, true), 257); 32 | 33 | // Write value to DataView on SharedArrayBuffer 34 | 35 | view.setUint16(3, 257, true); 36 | assert.sameValue(u8[3], 1); 37 | assert.sameValue(u8[4], 2); 38 | 39 | // BEGIN EPILOGUE 40 | finishTest("dataview-props"); 41 | // END EPILOGUE 42 | -------------------------------------------------------------------------------- /test262/futex-misc.js: -------------------------------------------------------------------------------- 1 | // Copyright (C) 2015 Mozilla Corporation. All rights reserved. 2 | // This code is governed by the BSD license found in the LICENSE file. 3 | 4 | // BEGIN PROLOGUE 5 | beginTest("futex-misc"); 6 | // END PROLOGUE 7 | 8 | /*--- 9 | es7id: TBD 10 | description: > 11 | Test miscellaneous aspects of futex operations 12 | ---*/ 13 | 14 | var sab = new SharedArrayBuffer(4); 15 | var view = new Int32Array(sab); 16 | 17 | // Testing the actual functioning of these requires workers, see 18 | // ../test-html/ for more test cases. 19 | 20 | // Legal corner cases for Atomics.wake(). 21 | 22 | assert.sameValue(Atomics.wake(view, 0, -3), 0); 23 | assert.sameValue(Atomics.wake(view, 0, Number.POSITIVE_INFINITY), 0); 24 | assert.sameValue(Atomics.wake(view, 0), 0); 25 | 26 | // BEGIN EPILOGUE 27 | finishTest("futex-misc"); 28 | // END EPILOGUE 29 | -------------------------------------------------------------------------------- /test262/futex-on-nonshared-int-arrays.js: -------------------------------------------------------------------------------- 1 | // Copyright (C) 2015 Mozilla Corporation. All rights reserved. 2 | // This code is governed by the BSD license found in the LICENSE file. 3 | 4 | // BEGIN PROLOGUE 5 | beginTest("futex-on-nonshared-int-arrays"); 6 | // END PROLOGUE 7 | 8 | /*--- 9 | es7id: TBD 10 | description: > 11 | Test futex operations on non-shared integer TypedArrays 12 | ---*/ 13 | 14 | var ab = new ArrayBuffer(16); 15 | 16 | var int_views = [Int8Array, Uint8Array, Int16Array, Uint16Array, Int32Array, Uint32Array]; 17 | 18 | for ( var View of int_views ) { 19 | var view = new View(ab); 20 | 21 | assert.throws(TypeError, (() => Atomics.wait(view, 0, 0))); 22 | assert.throws(TypeError, (() => Atomics.wake(view, 0))); 23 | } 24 | 25 | // BEGIN EPILOGUE 26 | finishTest("futex-on-nonshared-int-arrays"); 27 | // END EPILOGUE 28 | -------------------------------------------------------------------------------- /test262/futex-on-other-stuff.js: -------------------------------------------------------------------------------- 1 | // Copyright (C) 2015 Mozilla Corporation. All rights reserved. 2 | // This code is governed by the BSD license found in the LICENSE file. 3 | 4 | // BEGIN PROLOGUE 5 | beginTest("futex-on-other-stuff"); 6 | // END PROLOGUE 7 | 8 | /*--- 9 | es7id: TBD 10 | description: > 11 | Test futex operations on values other than TypedArrays 12 | ---*/ 13 | 14 | var values = [null, 15 | undefined, 16 | true, 17 | false, 18 | new Boolean(true), 19 | 10, 20 | 3.14, 21 | new Number(4), 22 | "Hi there", 23 | new Date, 24 | /a*utomaton/g, 25 | { password: "qumquat" }, 26 | new DataView(new ArrayBuffer(10)), 27 | new ArrayBuffer(128), 28 | new SharedArrayBuffer(128), 29 | new Error("Ouch"), 30 | [1,1,2,3,5,8], 31 | ((x) => -x), 32 | new Map(), 33 | new Set(), 34 | new WeakMap(), 35 | new WeakSet(), 36 | this.Promise ? new Promise(() => "done") : undefined, 37 | Symbol("halleluja"), 38 | // TODO: Proxy? 39 | Object, 40 | Int32Array, 41 | Date, 42 | Math, 43 | Atomics ]; 44 | 45 | for ( var i=0 ; i < values.length ; i++ ) { 46 | var view = values[i]; 47 | assert.throws(TypeError, (() => Atomics.wait(view, 0, 0))); 48 | assert.throws(TypeError, (() => Atomics.wake(view, 0))); 49 | } 50 | 51 | // BEGIN EPILOGUE 52 | finishTest("futex-on-other-stuff"); 53 | // END EPILOGUE 54 | -------------------------------------------------------------------------------- /test262/futex-on-shared-nonint-arrays.js: -------------------------------------------------------------------------------- 1 | // Copyright (C) 2015 Mozilla Corporation. All rights reserved. 2 | // This code is governed by the BSD license found in the LICENSE file. 3 | 4 | // BEGIN PROLOGUE 5 | beginTest("futex-on-shared-nonint-arrays"); 6 | // END PROLOGUE 7 | 8 | /*--- 9 | es7id: TBD 10 | description: > 11 | Test futex operations on shared non-integer TypedArrays 12 | ---*/ 13 | 14 | var sab = new SharedArrayBuffer(1024); 15 | 16 | var other_views = [Uint8ClampedArray, Float32Array, Float64Array]; 17 | 18 | for ( var View of other_views ) { 19 | var view = new View(sab); 20 | 21 | assert.throws(TypeError, (() => Atomics.wait(view, 0, 0))); 22 | assert.throws(TypeError, (() => Atomics.wake(view, 0))); 23 | } 24 | 25 | // BEGIN EPILOGUE 26 | finishTest("futex-on-shared-nonint-arrays"); 27 | // END EPILOGUE 28 | -------------------------------------------------------------------------------- /test262/futex-on-shared-nonint32-arrays.js: -------------------------------------------------------------------------------- 1 | // Copyright (C) 2015 Mozilla Corporation. All rights reserved. 2 | // This code is governed by the BSD license found in the LICENSE file. 3 | 4 | // BEGIN PROLOGUE 5 | beginTest("futex-on-shared-nonint32-arrays"); 6 | // END PROLOGUE 7 | 8 | /*--- 9 | es7id: TBD 10 | description: > 11 | Test atomic operations on shared non-int32 arrays 12 | ---*/ 13 | 14 | var sab = new SharedArrayBuffer(16); 15 | 16 | var int_views = [Int8Array, Uint8Array, Int16Array, Uint16Array, Uint32Array]; 17 | 18 | for ( var View of int_views ) { 19 | var view = new View(sab); 20 | 21 | assert.throws(TypeError, (() => Atomics.wait(view, 0, 0))); 22 | assert.throws(TypeError, (() => Atomics.wake(view, 0))); 23 | } 24 | 25 | // BEGIN EPILOGUE 26 | finishTest("futex-on-shared-nonint32-arrays"); 27 | // END EPILOGUE 28 | -------------------------------------------------------------------------------- /test262/futex-range.js: -------------------------------------------------------------------------------- 1 | // Copyright (C) 2015 Mozilla Corporation. All rights reserved. 2 | // This code is governed by the BSD license found in the LICENSE file. 3 | 4 | // BEGIN PROLOGUE 5 | beginTest("futex-range"); 6 | // END PROLOGUE 7 | 8 | /*--- 9 | es7id: TBD 10 | description: > 11 | Test range checking of futex operations (on arrays that allow atomic operations) 12 | ---*/ 13 | 14 | var sab = new SharedArrayBuffer(4); 15 | var view = new Int32Array(sab); 16 | 17 | var bad_indices = [ 18 | (view) => -1, 19 | (view) => view.length, 20 | (view) => view.length*2, 21 | (view) => undefined, 22 | (view) => '3.5', 23 | (view) => 3.5, 24 | (view) => ({ password: "qumquat" }), 25 | (view) => ({ valueOf: () => 125 }), 26 | (view) => ({ toString: () => '125', valueOf: false }) // non-callable valueOf triggers invocation of toString 27 | ]; 28 | 29 | for ( var iidx=0 ; iidx < bad_indices.length ; iidx++ ) { 30 | var Idx = bad_indices[iidx](view); 31 | assert.throws(RangeError, () => Atomics.wait(view, Idx, 10)); 32 | assert.throws(RangeError, () => Atomics.wake(view, Idx)); 33 | } 34 | 35 | var good_indices = [ (view) => 0/-1, // -0 36 | (view) => '-0', 37 | (view) => view.length - 1, 38 | (view) => ({ valueOf: () => 0 }), 39 | (view) => ({ toString: () => '0', valueOf: false }) // non-callable valueOf triggers invocation of toString 40 | ]; 41 | 42 | for ( var iidx=0 ; iidx < good_indices.length ; iidx++ ) { 43 | var Idx = good_indices[iidx](view); 44 | //Atomics.wait(view, Idx, 10); // Will not block, but may throw on the main thread 45 | Atomics.wake(view, Idx); // Wakes none 46 | } 47 | 48 | 49 | // BEGIN EPILOGUE 50 | finishTest("futex-range"); 51 | // END EPILOGUE 52 | -------------------------------------------------------------------------------- /test262/futex-wait-return.js: -------------------------------------------------------------------------------- 1 | // Copyright (C) 2015 Mozilla Corporation. All rights reserved. 2 | // This code is governed by the BSD license found in the LICENSE file. 3 | 4 | // BEGIN PROLOGUE 5 | beginTest("futex-wait-return"); 6 | // END PROLOGUE 7 | 8 | /*--- 9 | es7id: TBD 10 | description: > 11 | Test some return values of Atomics.wait() 12 | ---*/ 13 | 14 | var sab = new SharedArrayBuffer(4); 15 | var view = new Int32Array(sab); 16 | 17 | // Testing for "ok" requires workers, see ../test-html/ for more test 18 | // cases. 19 | 20 | assert.sameValue(Atomics.wait(view, 0, 42), "not-equal"); 21 | assert.sameValue(Atomics.wait(view, 0, 0, 100), "timed-out"); 22 | 23 | // BEGIN EPILOGUE 24 | finishTest("futex-wait-return"); 25 | // END EPILOGUE 26 | -------------------------------------------------------------------------------- /test262/harness.js: -------------------------------------------------------------------------------- 1 | // This mimics, superficially, the test262 harness 2 | 3 | var _count = 0; 4 | var _errors = 0; 5 | 6 | var assert = { 7 | 8 | sameValue: function (got, expected) { 9 | 10 | function same(a, b) { 11 | var pass = true; 12 | if (typeof a != typeof b) 13 | pass = false; 14 | else if (typeof a == "number") { 15 | if (a != b) 16 | pass = isNaN(a) && isNaN(b); 17 | else if (a == 0) 18 | pass = (1/a == 1/b); 19 | } 20 | else if (typeof a == "string" || typeof a == "boolean" || typeof a == "undefined") 21 | pass = (a == b); 22 | else if (Array.isArray(a) && Array.isArray(b)) { 23 | if (a.length != b.length) 24 | pass = false; 25 | else { 26 | var limit = a.length; 27 | for ( var i=0 ; i < limit && pass ; i++ ) 28 | pass = same(a[i], b[i]); 29 | } 30 | } 31 | // TODO: view types! 32 | else 33 | pass = (a == b); 34 | return pass; 35 | } 36 | 37 | ++_count; 38 | if (!same(got, expected)) 39 | fail("Failed: got " + got + ", expected " + expected); 40 | }, 41 | 42 | throws: function (error, thunk) { 43 | ++_count; 44 | var failed = false; 45 | var failure; 46 | try { 47 | thunk(); 48 | } 49 | catch (e) { 50 | failed = true; 51 | failure = e; 52 | } 53 | if (!failed) 54 | fail("Failed: expected " + error.name + " exception, did not fail: " + thunk); 55 | if (!(failure instanceof error)) 56 | fail("Failed: expected " + error.name + ", got " + failure); 57 | } 58 | }; 59 | 60 | function clearCount() { 61 | _count = 0; 62 | _errors = 0; 63 | } 64 | 65 | function getCount() { 66 | return _count; 67 | } 68 | 69 | // Hooks that are overridden by the HTML test runner 70 | 71 | function beginTest() { 72 | } 73 | 74 | function finishTest() { 75 | } 76 | 77 | function classifyTest() {} 78 | 79 | function fail(s) { 80 | msg(s); 81 | if (++_errors >= 100) { 82 | msg("BAILING OUT"); 83 | throw new Error(s); 84 | } 85 | } 86 | 87 | function msg(s) { 88 | if (this.console && this.console.log) 89 | this.console.log(s); 90 | } 91 | -------------------------------------------------------------------------------- /test262/is-lock-free-corner-cases.js: -------------------------------------------------------------------------------- 1 | // Copyright (C) 2015 Mozilla Corporation. All rights reserved. 2 | // This code is governed by the BSD license found in the LICENSE file. 3 | 4 | // BEGIN PROLOGUE 5 | beginTest("is-lock-free-corner-cases"); 6 | // END PROLOGUE 7 | 8 | /*--- 9 | es7id: TBD 10 | description: > 11 | Test isLockFree on various non-intuitive arguments 12 | ---*/ 13 | 14 | assert.sameValue(false, Atomics.isLockFree(hide(3, Number.NaN))); 15 | assert.sameValue(false, Atomics.isLockFree(hide(3, -1))); 16 | assert.sameValue(false, Atomics.isLockFree(hide(3, 3.14))); 17 | assert.sameValue(false, Atomics.isLockFree(hide(3, 0))); 18 | 19 | assert.sameValue(Atomics.isLockFree('1'), Atomics.isLockFree(1)); 20 | assert.sameValue(Atomics.isLockFree('3'), Atomics.isLockFree(3)); 21 | 22 | assert.sameValue(Atomics.isLockFree(true), Atomics.isLockFree(1)); 23 | 24 | assert.sameValue(Atomics.isLockFree(1), Atomics.isLockFree({valueOf: () => 1})); 25 | assert.sameValue(Atomics.isLockFree(3), Atomics.isLockFree({valueOf: () => 3})); 26 | assert.sameValue(Atomics.isLockFree(1), Atomics.isLockFree({toString: () => '1'})); 27 | assert.sameValue(Atomics.isLockFree(3), Atomics.isLockFree({toString: () => '3'})); 28 | 29 | function hide(k, x) { 30 | if (k) 31 | return hide(k-3, x) + x; 32 | return 0; 33 | } 34 | 35 | // BEGIN EPILOGUE 36 | finishTest("is-lock-free-corner-cases"); 37 | // END EPILOGUE 38 | 39 | -------------------------------------------------------------------------------- /test262/is-lock-free-good.js: -------------------------------------------------------------------------------- 1 | // Copyright (C) 2015 Mozilla Corporation. All rights reserved. 2 | // This code is governed by the BSD license found in the LICENSE file. 3 | 4 | // BEGIN PROLOGUE 5 | beginTest("is-lock-free-good"); 6 | // END PROLOGUE 7 | 8 | /*--- 9 | es7id: TBD 10 | description: > 11 | Test isLockFree on nonnegative integer arguments 12 | ---*/ 13 | 14 | var sizes = [ 1, 2, 3, 4, 5, 6, 7, 8, 15 | 9, 10, 11, 12]; 16 | var answers = [ {}, {}, false, true, false, false, false, false, 17 | false, false, false, false]; 18 | 19 | function testIsLockFree() { 20 | var saved = {}; 21 | 22 | // This should defeat most optimizations. 23 | 24 | for ( var i=0 ; i < sizes.length ; i++ ) { 25 | var v = Atomics.isLockFree(sizes[i]); 26 | var a = answers[i]; 27 | assert.sameValue(typeof v, 'boolean'); 28 | if (typeof a == 'boolean') 29 | assert.sameValue(v, a); 30 | else 31 | saved[sizes[i]] = v; 32 | } 33 | 34 | // This ought to be optimizable. Make sure the answers are the same 35 | // as for the unoptimized case. 36 | 37 | assert.sameValue(Atomics.isLockFree(1), saved[1]); 38 | assert.sameValue(Atomics.isLockFree(2), saved[2]); 39 | assert.sameValue(Atomics.isLockFree(3), false); 40 | assert.sameValue(Atomics.isLockFree(4), true); 41 | assert.sameValue(Atomics.isLockFree(5), false); 42 | assert.sameValue(Atomics.isLockFree(6), false); 43 | assert.sameValue(Atomics.isLockFree(7), false); 44 | assert.sameValue(Atomics.isLockFree(8), false); 45 | assert.sameValue(Atomics.isLockFree(9), false); 46 | assert.sameValue(Atomics.isLockFree(10), false); 47 | assert.sameValue(Atomics.isLockFree(11), false); 48 | assert.sameValue(Atomics.isLockFree(12), false); 49 | } 50 | 51 | testIsLockFree(); 52 | 53 | // BEGIN EPILOGUE 54 | finishTest("is-lock-free-good"); 55 | // END EPILOGUE 56 | 57 | -------------------------------------------------------------------------------- /test262/runner.html: -------------------------------------------------------------------------------- 1 | 2 | 3 | 4 | 5 | 6 |13 | 14 | 15 | 24 | 25 | 26 | 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 | 94 | 95 | 96 | -------------------------------------------------------------------------------- /test262/shared-array-buffer-conversion.js: -------------------------------------------------------------------------------- 1 | // Copyright (C) 2015 Mozilla Corporation. All rights reserved. 2 | // This code is governed by the BSD license found in the LICENSE file. 3 | 4 | /*--- 5 | es7id: TBD 6 | description: > 7 | Test conversion of a SharedArrayBuffer object to various types 8 | ---*/ 9 | 10 | // BEGIN PROLOGUE 11 | beginTest("shared-array-buffer-conversion"); 12 | // END PROLOGUE 13 | 14 | var sab = new SharedArrayBuffer(1024); 15 | 16 | assert.sameValue(String(sab), "[object SharedArrayBuffer]"); 17 | 18 | assert.sameValue(Number(sab), Number.NaN); 19 | 20 | // BEGIN EPILOGUE 21 | finishTest("shared-array-buffer-conversion"); 22 | // END EPILOGUE 23 | -------------------------------------------------------------------------------- /test262/shared-array-buffer-instance-props.js: -------------------------------------------------------------------------------- 1 | // Copyright (C) 2015 Mozilla Corporation. All rights reserved. 2 | // This code is governed by the BSD license found in the LICENSE file. 3 | 4 | /*--- 5 | es7id: TBD 6 | description: > 7 | Test properties and methods of the SharedArrayBuffer instances 8 | ---*/ 9 | 10 | // BEGIN PROLOGUE 11 | beginTest("shared-array-buffer-instance-props"); 12 | // END PROLOGUE 13 | 14 | var sab = new SharedArrayBuffer(1024); 15 | 16 | assert.sameValue(sab.byteLength, 1024); 17 | 18 | assert.sameValue(sab.constructor, SharedArrayBuffer); 19 | 20 | assert.sameValue(sab.slice, SharedArrayBuffer.prototype.slice); 21 | 22 | assert.sameValue(typeof sab.slice, "function"); 23 | 24 | // Not implemented in Firefox 46 25 | if (sab.slice) { 26 | // TODO: test SharedArrayBuffer.prototype.slice 27 | } 28 | 29 | // BEGIN EPILOGUE 30 | finishTest("shared-array-buffer-instance-props"); 31 | // END EPILOGUE 32 | -------------------------------------------------------------------------------- /test262/shared-array-buffer-props.js: -------------------------------------------------------------------------------- 1 | // Copyright (C) 2015 Mozilla Corporation. All rights reserved. 2 | // This code is governed by the BSD license found in the LICENSE file. 3 | 4 | /*--- 5 | es7id: TBD 6 | description: > 7 | Test properties of the SharedArrayBuffer object 8 | ---*/ 9 | 10 | // BEGIN PROLOGUE 11 | beginTest("shared-array-buffer-props"); 12 | // END PROLOGUE 13 | 14 | assert.sameValue(typeof SharedArrayBuffer.isView, "function"); 15 | assert.sameValue(typeof SharedArrayBuffer.prototype, "object"); 16 | assert.sameValue(typeof SharedArrayBuffer.prototype == null, false); 17 | 18 | // BEGIN EPILOGUE 19 | finishTest("shared-array-buffer-props"); 20 | // END EPILOGUE 21 | -------------------------------------------------------------------------------- /test262/shell-runner: -------------------------------------------------------------------------------- 1 | #!/bin/bash 2 | for i in "shared-array-buffer-props.js" \ 3 | "shared-array-buffer-instance-props.js" \ 4 | "shared-array-buffer-conversion.js" \ 5 | "typedarray-props.js" \ 6 | "typedarray-props-range.js" \ 7 | "dataview-props.js" \ 8 | "atomics-on-good-arrays.js" \ 9 | "atomics-on-nonshared-int-arrays.js" \ 10 | "atomics-on-shared-nonint-arrays.js" \ 11 | "atomics-on-other-stuff.js" \ 12 | "atomics-range.js" \ 13 | "futex-on-shared-nonint32-arrays.js" \ 14 | "futex-on-nonshared-int-arrays.js" \ 15 | "futex-on-shared-nonint-arrays.js" \ 16 | "futex-on-other-stuff.js" \ 17 | "futex-range.js" \ 18 | "futex-misc.js" \ 19 | "futex-wait-return.js" \ 20 | "is-lock-free-good.js" \ 21 | "is-lock-free-corner-cases.js" \ 22 | "wait-wake.js" 23 | do 24 | echo "" 25 | echo "=================================================" 26 | echo $i 27 | # This is correct for the SpiderMonkey shell, contributions for 28 | # other shells are welcome. 29 | $JSSHELL -f harness.js -f agenttest_spidermonkey.js -f $i 30 | done 31 | -------------------------------------------------------------------------------- /test262/typedarray-props-range.js: -------------------------------------------------------------------------------- 1 | // Copyright (C) 2015 Mozilla Corporation. All rights reserved. 2 | // This code is governed by the BSD license found in the LICENSE file. 3 | 4 | // BEGIN PROLOGUE 5 | beginTest("typedarray-props-range"); 6 | // END PROLOGUE 7 | 8 | /*--- 9 | es7id: TBD 10 | description: > 11 | Test out-of-range access on typed array views on shared memory 12 | ---*/ 13 | 14 | var sab = new SharedArrayBuffer(8); 15 | 16 | var views = [Int8Array, Uint8Array, Int16Array, Uint16Array, Int32Array, Uint32Array, 17 | Uint8ClampedArray, Float64Array, Float32Array]; 18 | 19 | var i = 0; 20 | for ( var View of views ) { 21 | var view = new View(sab); 22 | 23 | // Note, non-index numbers are added as expandos, so avoid those. 24 | 25 | // No exception should be thrown here 26 | 27 | assert.sameValue(view[-1] = 5, 5); 28 | assert.sameValue(view[view.length] = 5, 5); 29 | assert.sameValue(view['10000'] = 5, 5); 30 | 31 | // Nor exceptions here 32 | 33 | assert.sameValue(view[-1], undefined); 34 | assert.sameValue(view[view.length], undefined); 35 | assert.sameValue(view['10000'], undefined); 36 | } 37 | 38 | // BEGIN EPILOGUE 39 | finishTest("typedarray-props-range"); 40 | // END EPILOGUE 41 | -------------------------------------------------------------------------------- /test262/typedarray-props.js: -------------------------------------------------------------------------------- 1 | // Copyright (C) 2015 Mozilla Corporation. All rights reserved. 2 | // This code is governed by the BSD license found in the LICENSE file. 3 | 4 | // BEGIN PROLOGUE 5 | beginTest("typedarray-props"); 6 | // END PROLOGUE 7 | 8 | /*--- 9 | es7id: TBD 10 | description: > 11 | Test the properties of typed array views on shared memory 12 | ---*/ 13 | 14 | var sab = new SharedArrayBuffer(1024); 15 | 16 | var int_views = [Int8Array, Uint8Array, Int16Array, Uint16Array, Int32Array, Uint32Array]; 17 | 18 | var other_views = [Uint8ClampedArray, Float32Array, Float64Array]; 19 | 20 | ////////////////////////////////////////////////////////////////////// 21 | // 22 | // Test that the views can be constructed on shared memory and that 23 | // the memory extracted from the views is the original shared buffer, 24 | // and other basic things. 25 | 26 | for ( var View of int_views ) 27 | testView(View); 28 | 29 | for ( var View of other_views ) 30 | testView(View); 31 | 32 | function testView(View) { 33 | var view = new View(sab); 34 | 35 | assert.sameValue(view.buffer, sab); 36 | assert.sameValue(view.length, sab.byteLength / View.BYTES_PER_ELEMENT); 37 | assert.sameValue(view.byteOffset, 0); 38 | 39 | var half = sab.byteLength/2; 40 | var view2 = new View(sab, half); 41 | 42 | assert.sameValue(view2.buffer, sab); 43 | assert.sameValue(view2.length, half / View.BYTES_PER_ELEMENT); 44 | assert.sameValue(view2.byteOffset, half) 45 | 46 | var view3 = new View(sab, View.BYTES_PER_ELEMENT, 5); 47 | 48 | assert.sameValue(view3.buffer, sab); 49 | assert.sameValue(view3.length, 5); 50 | assert.sameValue(view3.byteOffset, View.BYTES_PER_ELEMENT); 51 | } 52 | 53 | //////////////////////////////////////////////////////////// 54 | // 55 | // Basic element read/write. 56 | 57 | for ( var View of int_views ) { 58 | var view = new View(sab, 8, 10); 59 | 60 | var tmp = new Uint8Array(sab, 8, 1); 61 | assert.sameValue(tmp[0], 0); 62 | view[0] = -1; 63 | assert.sameValue(tmp[0], 255); 64 | view[0] = 0; 65 | assert.sameValue(tmp[0], 0); 66 | } 67 | 68 | var cuview = new Uint8ClampedArray(sab, 8, 10); 69 | cuview[3] = 1; 70 | assert.sameValue(cuview[3], 1); 71 | cuview[3] = -1; 72 | assert.sameValue(cuview[3], 0); 73 | cuview[3] = 4711; 74 | assert.sameValue(cuview[3], 255); 75 | cuview[3] = 0; 76 | 77 | var f64view = new Float64Array(sab, 8, 10); 78 | f64view[3] = Math.PI; 79 | assert.sameValue(f64view[3], Math.PI); 80 | f64view[3] = 0; 81 | 82 | var f32view = new Float32Array(sab, 8, 10); 83 | f32view[0] = Math.PI; 84 | assert.sameValue(f32view[0], Math.fround(Math.PI)); 85 | f32view[0] = 0; 86 | 87 | //////////////////////////////////////////////////////////// 88 | 89 | // TypedArray methods: 90 | // 91 | // All existing TypedArray methods should work the same (in a 92 | // single-threaded setting) if the underlying buffer is a shared 93 | // buffer, so I'm delegating most functional tests to existing test 94 | // suites (that will have to be adapted mildly). 95 | 96 | // The spec has a change to the set() method to prevent overwriting 97 | // elements when the underlying memory of two SharedArrayBuffers is 98 | // the same (as can happen if a SAB is sent to another agent and then 99 | // back to the first one; we end up with two SAB objects that 100 | // reference the same memory). That change can't be tested in a 101 | // shell, it needs to be tested in a browser. 102 | 103 | 104 | // BEGIN EPILOGUE 105 | finishTest("typedarray-props"); 106 | // END EPILOGUE 107 | -------------------------------------------------------------------------------- /test262/wait-wake.js: -------------------------------------------------------------------------------- 1 | // Copyright (C) 2015 Mozilla Corporation. All rights reserved. 2 | // This code is governed by the BSD license found in the LICENSE file. 3 | 4 | // BEGIN PROLOGUE 5 | beginTest("wait-wake"); 6 | // END PROLOGUE 7 | 8 | /*--- 9 | es7id: TBD 10 | description: > 11 | Test Atomics.wait and Atomics.wake 12 | ---*/ 13 | 14 | // Test that "wait" actually waits and does not spuriously wake up 15 | // when the memory value is changed. 16 | 17 | AgentTest.start( 18 | ` 19 | var { sab } = AgentTest.receive(); 20 | var ia = new Int32Array(sab); 21 | 22 | var then = Date.now(); 23 | Atomics.wait(ia, 0, 0); 24 | var diff = Date.now() - then; // Should be about 1000 ms 25 | AgentTest.report(diff); 26 | 27 | AgentTest.leaving(); 28 | `); 29 | 30 | var ia = new Int32Array(new SharedArrayBuffer(Int32Array.BYTES_PER_ELEMENT)); 31 | AgentTest.broadcast(ia.buffer); 32 | 33 | var then = Date.now(); 34 | AgentTest.sleep(500); // Give the agent a chance to wait 35 | Atomics.store(ia, 0, 1); // Change the value, should not wake the agent 36 | AgentTest.sleep(500); // Wait some more so that we can tell 37 | Atomics.wake(ia, 0); // Really wake it up 38 | AgentTest.sleep(500); // Give it time to report back 39 | assert.sameValue(Math.abs((AgentTest.getReport()|0) - 1000) < 100, true); 40 | 41 | // BEGIN EPILOGUE 42 | finishTest("wait-wake"); 43 | // END EPILOGUE 44 | --------------------------------------------------------------------------------