SharedArrayBuffer en atomics voor WASM

Bij het bouwen van applicaties met hoge prestaties met WebAssembly (WASM) moet je vaak gegevens delen tussen verschillende onderdelen van je programma, vooral tussen meerdere threads (Web Workers).

Geheugen rechtstreeks delen kan problemen veroorzaken, zoals racecondities, waarbij meerdere threads tegelijkertijd dezelfde gegevens proberen te lezen en te wijzigen, met onvoorspelbare resultaten als gevolg.

In deze les maak je kennis met SharedArrayBuffer en atomaire bewerkingen, essentiële hulpmiddelen voor het veilig en efficiënt delen van gegevens in WASM-applicaties met meerdere threads.

Een SharedArrayBuffer is een speciaal type gegevensbuffer in JavaScript dat kan worden gedeeld tussen de hoofdthread en Web Workers.

• In tegenstelling tot een gewone ArrayBuffer, die alleen naar een worker kan worden overgedragen (gekopieerd), biedt een SharedArrayBuffer een gedeelde geheugenruimte.
• Dit betekent dat alle threads die er toegang toe hebben dezelfde gegevens tegelijkertijd zien, zonder dat deze heen en weer moeten worden gekopieerd.
• Het vormt de basis voor echte multithreading met WASM in webomgevingen.

Je maakt aan de JavaScript-kant een SharedArrayBuffer, net als een gewone ArrayBuffer, maar met de constructor SharedArrayBuffer.

Na het maken kun je weergaven van getypeerde arrays maken (bijvoorbeeld Uint32Array) om gegevens te lezen en te schrijven. Deze buffer kan vervolgens worden doorgegeven aan Web Workers.

Zo kun je er een instellen in JavaScript:

// In JavaScript:
const sharedBuffer = new SharedArrayBuffer(1024); // 1KB shared memory
const view = new Uint32Array(sharedBuffer); // A view to work with

// Now, 'sharedBuffer' can be passed to Web Workers
// worker.postMessage({ sharedBuffer });

WASM-modules die in deze workers zijn geladen, kunnen vervolgens toegang krijgen tot dit gedeelde geheugen.

Wanneer een SharedArrayBuffer aan een Web Worker wordt doorgegeven en een WebAssembly-module wordt geïnstantieerd met een WebAssembly.Memory-object dat deze gedeelde buffer gebruikt, krijgt de WASM-module rechtstreeks toegang tot die buffer.

• WASM ziet dit gedeelde geheugen als zijn eigen lineaire geheugen.
• Alle lees- en schrijfbewerkingen van de WASM-module in zijn lineaire geheugen worden rechtstreeks weerspiegeld in de SharedArrayBuffer.
• Hierdoor kunnen WASM-instanties die in verschillende workers worden uitgevoerd in realtime met exact dezelfde gegevens werken.

Stel je twee Web Workers voor die elk een WASM-module uitvoeren en een gedeelde teller in een SharedArrayBuffer proberen te verhogen.

Als beide workers de huidige waarde lezen, deze verhogen en vervolgens zonder coördinatie terugschrijven, kan er een raceconditie ontstaan:

• Worker A leest 0.
• Worker B leest 0.
• Worker A verhoogt 0 naar 1 en schrijft 1.
• Worker B verhoogt 0 naar 1 en schrijft 1.

De teller zou 2 moeten zijn, maar eindigt als 1! Hier worden atomaire bewerkingen cruciaal.

Atomaire bewerkingen zijn speciale instructies die garanderen dat een bewerking volledig wordt uitgevoerd zonder onderbreking door andere threads.

Ze zijn "alles of niets": de volledige bewerking wordt succesvol voltooid of gebeurt helemaal niet. Zo worden gedeeltelijke updates en racecondities voorkomen.

Belangrijke kenmerken:

• Ondeelbaar: Kan niet worden onderbroken door een andere thread.
• Gegarandeerd: Waarborgt de integriteit van gegevens bij gelijktijdige toegang.
• Essentieel: Voor het bouwen van betrouwbare applicaties met meerdere threads.

Rust biedt atomaire typen (zoals AtomicU32 en AtomicI64) in zijn module std::sync::atomic. Deze kunnen worden gebruikt wanneer je naar WebAssembly compileert.

Wanneer deze bewerkingen naar WASM worden gecompileerd, worden ze vertaald naar de onderliggende atomaire WebAssembly-instructies, die veilig werken op gedeeld lineair geheugen.

Hier volgt een eenvoudig Rust-voorbeeld met een atomaire teller die onderdeel kan zijn van een WASM-module:

JavaScript heeft ook een eigen Atomics-object. Dit biedt statische methoden om rechtstreeks atomaire bewerkingen uit te voeren op weergaven van SharedArrayBuffer.

Hiermee kunnen de hoofdthread van JavaScript of Web Workers atomaire bewerkingen uitvoeren op het gedeelde geheugen en zo samenwerken met WASM-modules.

• Atomics.add(view, index, value): Voegt value atomair toe aan het element op index in view.
• Atomics.load(view, index): Laadt atomair de waarde op index.
• Atomics.store(view, index, value): Slaat value atomair op op index.

Deze methoden zijn cruciaal om vanuit JavaScript veilig te communiceren met het gedeelde geheugen van WASM.

Naast eenvoudige lees- en schrijfbewerkingen biedt Atomics ook methoden voor geavanceerdere threadsynchronisatie:

• Atomics.wait(view, index, expectedValue, timeout): Hiermee kan een thread slapen (blokkeren) totdat een specifieke geheugenlocatie (view[index]) niet langer expectedValue bevat, of totdat er een time-out optreedt.
• Atomics.notify(view, index, count): Hiermee worden een of meer threads gewekt die op de opgegeven geheugenlocatie wachten.

Dit zijn krachtige hulpmiddelen voor het bouwen van complexe patronen met meerdere threads, zoals producent-consumentwachtrijen, waarbij threads moeten pauzeren en hervatten op basis van wijzigingen in gedeelde gegevens.

Door SharedArrayBuffer en atomische bewerkingen te combineren, kun je robuuste gelijktijdige toepassingen bouwen. Bijvoorbeeld een gedeelde teller:

• JavaScript: Maakt een SharedArrayBuffer en een weergave van het type Uint32Array.
• Web Workers: Elke worker ontvangt de SharedArrayBuffer en maakt een WASM-module-instantie.
• WASM-module: De WASM-code (zoals in ons Rust-voorbeeld) gebruikt atomische bewerkingen om een specifieke index in het lineaire geheugen te verhogen. Dit geheugen wordt ondersteund door de SharedArrayBuffer.

Deze opzet zorgt ervoor dat de uiteindelijke waarde altijd correct is, zelfs wanneer meerdere threads de teller snel verhogen, en voorkomt racecondities.

We hebben onderzocht hoe SharedArrayBuffer echt gedeeld geheugen tussen JavaScript-threads en WebAssembly-modules mogelijk maakt. Daarmee wordt de weg vrijgemaakt voor WASM-toepassingen met meerdere threads.

We hebben vooral geleerd dat atomische bewerkingen onmisbaar zijn om dit gedeelde geheugen veilig te beheren. Ze voorkomen racecondities en zorgen voor consistente gegevens wanneer meerdere threads dezelfde gegevens gelijktijdig benaderen en wijzigen.

Beheersing van deze concepten is essentieel voor het bouwen van snelle, betrouwbare WebAssembly-toepassingen die optimaal gebruikmaken van moderne processors met meerdere kernen.