Shared Memory & Atomics
Explore the use of SharedArrayBuffer and atomic operations for high-performance concurrent data access between WASM and JS.
Shared Memory & Atomics is a free WebAssembly (WASM) for High Performance Apps lesson on CoddyKit — lesson 3 of 4. You can read the complete lesson below for free — then practise it hands-on in the browser with a built-in code editor and a 24/7 AI tutor. It is part of the WebAssembly (WASM) for High Performance Apps learning path, one of 4 lessons in the course, and your progress syncs across the web and the CoddyKit app.
Concurrency & Shared Memory
When building high-performance applications, especially with WebAssembly, you often need to perform tasks concurrently. This means running parts of your code in parallel, perhaps across different threads.
For these concurrent tasks to work together efficiently, they often need to access and modify the same data. This is where shared memory comes in.
Why Not Just ArrayBuffer?
You might already know about ArrayBuffer for handling raw binary data in JavaScript. However, a standard ArrayBuffer cannot be directly shared between different execution contexts (like the main thread and a Web Worker, or between JavaScript and a WebAssembly thread).
Each context would get its own copy of the data, which is inefficient and complicated to synchronize for frequent updates.
Introducing SharedArrayBuffer
The solution for true concurrent data access is SharedArrayBuffer. It's a special type of ArrayBuffer that allows the same memory block to be accessed by multiple threads simultaneously.
This means your JavaScript main thread, Web Workers, and WebAssembly modules can all read from and write to the *exact same* underlying data, enabling efficient communication and complex parallel computations.
Security Headers for Sharing
Due to security vulnerabilities (like Spectre), using SharedArrayBuffer requires specific HTTP response headers to be set by the server:
Cross-Origin-Opener-Policy: same-originCross-Origin-Embedder-Policy: require-corp
These headers ensure that the document is in an isolated, cross-origin isolated browsing context, which is necessary for SharedArrayBuffer to function securely.
Creating SharedArrayBuffer in JS
Creating a SharedArrayBuffer is similar to creating a regular ArrayBuffer. You specify the size in bytes. Then, you can create a typed array view (like Int32Array) to easily interact with the memory.
const sharedBuffer = new SharedArrayBuffer(1024); // 1KB
const sharedArray = new Int32Array(sharedBuffer);
console.log("Shared buffer created!");
console.log("Size:", sharedArray.length * Int32Array.BYTES_PER_ELEMENT, "bytes");WASM's View of Shared Memory
When a SharedArrayBuffer is passed to a WebAssembly module (e.g., via WebAssembly.Memory), WASM can map this memory into its own linear memory space. This allows WASM code to directly read and write to the shared data.
This direct access is key for performance, as it avoids costly data copying between the host environment (JavaScript) and the WASM module.
Race Conditions & Data Safety
While sharing memory is powerful, it introduces a challenge: race conditions. If multiple threads try to read and write to the same memory location at the same time, the final result can be unpredictable or incorrect.
Imagine two threads trying to increment a counter simultaneously. Without proper synchronization, one update might overwrite another, leading to a wrong count.
Introducing Atomics for Safety
To prevent race conditions, JavaScript provides the Atomics object. Atomics offer a set of operations that are guaranteed to be atomic, meaning they are indivisible.
An atomic operation either completes entirely or doesn't happen at all, ensuring that no other thread can interrupt it. This guarantees data integrity in shared memory.
Atomic Reads and Writes
The most basic atomic operations are `Atomics.load()` and `Atomics.store()`. These methods ensure that reading and writing values to a shared memory location happens as a single, uninterruptible step.
const sharedBuffer = new SharedArrayBuffer(4); // 4 bytes
const int32View = new Int32Array(sharedBuffer);
// Safely store a value at index 0
Atomics.store(int32View, 0, 100);
console.log("Stored 100 atomically.");
// Safely load a value from index 0
const value = Atomics.load(int32View, 0);
console.log("Loaded value:", value);Atomic Arithmetic Operations
Beyond simple reads/writes, Atomics provide arithmetic operations like Atomics.add(), Atomics.sub(), Atomics.and(), etc. These perform an operation and update the value atomically.
Atomics.add(typedArray, index, value) adds value to the element at index and returns the old value at that index, all in one safe step.
const sharedBuffer = new SharedArrayBuffer(4);
const int32View = new Int32Array(sharedBuffer);
Atomics.store(int32View, 0, 5); // Initial value
console.log("Initial value:", Atomics.load(int32View, 0));
// Atomically add 3 to the value at index 0
const oldValue = Atomics.add(int32View, 0, 3);
console.log("Old value before add:", oldValue);
console.log("New value after add:", Atomics.load(int32View, 0));Shared Memory Check
Consider the following JavaScript code snippet. Assume sharedBuffer is a properly configured SharedArrayBuffer and int32View is an Int32Array view of it.
const int32View = new Int32Array(sharedBuffer);
Atomics.store(int32View, 0, 5);
const result = Atomics.add(int32View, 0, 2);
const finalValue = Atomics.load(int32View, 0);Recap: Shared Memory & Atomics
We've explored how SharedArrayBuffer enables efficient concurrent data access between JavaScript and WebAssembly by allowing multiple threads to access the same memory block.
To prevent data corruption from race conditions, we learned about Atomics, which provide safe, indivisible operations for reading, writing, and modifying data in shared memory.
These tools are crucial for building high-performance, multithreaded WebAssembly applications.
Frequently asked questions
Is the “Shared Memory & Atomics” lesson free?
Yes — the full text of “Shared Memory & Atomics” is free to read here on the web, and the WebAssembly (WASM) for High Performance Apps course includes 4 lessons in total. To practise it interactively (a built-in code editor and a 24/7 AI tutor) and unlock the rest of the WebAssembly (WASM) for High Performance Apps course, upgrade to CoddyKit PRO.
What will I learn in “Shared Memory & Atomics”?
Explore the use of SharedArrayBuffer and atomic operations for high-performance concurrent data access between WASM and JS. You practise WebAssembly (WASM) for High Performance Apps with hands-on code you run directly in the browser, and a 24/7 AI tutor answers your questions as you work through the lesson.
Do I need any experience to start WebAssembly (WASM) for High Performance Apps?
No prior experience is required. WebAssembly (WASM) for High Performance Apps on CoddyKit is structured for beginners through advanced learners; this is — lesson 3 of 4, so you can start here or from the beginning and move at your own pace.
How long does the “Shared Memory & Atomics” lesson take?
Most CoddyKit lessons take about 5–10 minutes. Each one is bite-sized and interactive, so you make steady progress and pick up exactly where you left off across the web and the app.
Can I write and run code in this WebAssembly (WASM) for High Performance Apps lesson?
Yes. Every WebAssembly (WASM) for High Performance Apps lesson includes a built-in code editor, so you write and run real code right in your browser and get instant AI feedback — no local setup required.