SharedArrayBuffer ja atomiset operaatiot WASMia varten

Kun rakennatte suorituskykyisiä sovelluksia WebAssemblylla (WASM), joudutte usein jakamaan dataa ohjelman eri osien välillä, erityisesti useiden säikeiden (Web Workers) kesken.

Muistin suora jakaminen voi aiheuttaa ongelmia, kuten kilpailutilanteita, joissa useat säikeet yrittävät käyttää ja muokata samoja tietoja samanaikaisesti, mikä johtaa ennakoimattomiin tuloksiin.

Tässä oppitunnissa esitellään SharedArrayBuffer ja atomiset operaatiot, jotka ovat keskeisiä työkaluja turvalliseen ja tehokkaaseen datan jakamiseen monisäikeisissä WASM-sovelluksissa.

SharedArrayBuffer on JavaScriptin erityinen datapuskurin tyyppi, joka voidaan jakaa pääsäikeen ja Web Workereiden kesken.

• Toisin kuin tavallinen ArrayBuffer, joka voidaan vain siirtää (kopioida) workerille, SharedArrayBuffer tarjoaa jaetun muistitilan.
• Tämä tarkoittaa, että kaikki sitä käyttävät säikeet näkevät saman datan samanaikaisesti ilman, että dataa tarvitsee kopioida edestakaisin.
• Se muodostaa perustan todellisen monisäikeisyyden mahdollistamiselle WASM:lla verkkoympäristöissä.

Luotte SharedArrayBuffer-olion JavaScript-puolella samaan tapaan kuin tavallisen ArrayBuffer-olion, mutta käytätte SharedArrayBuffer-rakentajaa.

Kun olio on luotu, voitte luoda tyypitettyjä taulukkonäkymiä (esimerkiksi Uint32Array) datan lukemista ja kirjoittamista varten. Puskuri voidaan sitten välittää Web Workereille.

JavaScriptissä se voidaan alustaa esimerkiksi näin:

// 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 });

Näissä workereissa ladatut WASM-moduulit voivat sitten käyttää tätä jaettua muistia.

Kun SharedArrayBuffer välitetään Web Workerille ja WebAssembly-moduuli luodaan WebAssembly.Memory-oliolla, joka käyttää tätä jaettua puskuria, WASM-moduuli saa siihen suoran käyttöoikeuden.

• WASM näkee tämän jaetun muistin omana lineaarisena muistinaan.
• Kaikki WASM-moduulin lineaariseen muistiin tekemät luku- ja kirjoitusoperaatiot näkyvät suoraan SharedArrayBuffer-puskurissa.
• Tämän ansiosta eri workereissa suoritettavat WASM-instanssit voivat käsitellä täsmälleen samaa dataa reaaliaikaisesti.

Ajatellaan kahta Web Worker -säiettä, joissa kummassakin suoritetaan WASM-moduulia ja jotka yrittävät kasvattaa SharedArrayBuffer-puskurissa olevaa jaettua laskuria.

Jos molemmat workerit lukevat nykyisen arvon, kasvattavat sitä ja kirjoittavat sen takaisin ilman koordinointia, voi syntyä kilpailutilanne:

• Worker A lukee arvon 0.
• Worker B lukee arvon 0.
• Worker A kasvattaa arvon 0 arvoon 1 ja kirjoittaa arvon 1.
• Worker B kasvattaa arvon 0 arvoon 1 ja kirjoittaa arvon 1.

Laskurin pitäisi olla 2, mutta sen arvoksi tulee 1! Tässä atomiset operaatiot ovat ratkaisevan tärkeitä.

Atomiset operaatiot ovat erityisiä käskyjä, jotka takaavat operaation suorittamisen kokonaan ilman muiden säikeiden aiheuttamia keskeytyksiä.

Ne ovat ”kaikki tai ei mitään” -operaatioita: joko koko operaatio suoritetaan onnistuneesti tai sitä ei suoriteta lainkaan. Näin estetään osittaiset päivitykset ja kilpailutilanteet.

Keskeiset ominaisuudet:

• Jakamaton: Toinen säie ei voi keskeyttää operaatiota.
• Taattu: Varmistaa tietojen eheyden samanaikaisessa käytössä.
• Välttämätön: Luotettavien monisäikeisten sovellusten rakentamiseen.

Rust tarjoaa atomisia tyyppejä (kuten AtomicU32 ja AtomicI64) std::sync::atomic-moduulissaan. Niitä voidaan käyttää WebAssemblyksi käännettäessä.

WASM:ksi käännettynä nämä operaatiot muuttuvat taustalla oleviksi WebAssemblyn atomisiksi käskyiksi, jotka toimivat turvallisesti jaetussa lineaarisessa muistissa.

Tässä on yksinkertainen Rust-esimerkki atomisesta laskurista, joka voisi olla osa WASM-moduulia:

JavaScriptillä on myös oma Atomics-olionsa, joka tarjoaa staattisia metodeja atomisten operaatioiden suorittamiseen suoraan SharedArrayBuffer-puskurin näkymissä.

Tämän ansiosta JavaScriptin pääsäie tai Web Workerit voivat suorittaa atomisia operaatioita jaetussa muistissa ja koordinoida toimintaansa WASM-moduulien kanssa.

• Atomics.add(view, index, value): Lisää atomisesti value-arvon näkymän index-kohdassa olevaan alkioon.
• Atomics.load(view, index): Lataa atomisesti arvon kohdasta index.
• Atomics.store(view, index, value): Tallentaa atomisesti value-arvon kohtaan index.

Nämä metodit ovat ratkaisevan tärkeitä, jotta JavaScript voi käsitellä WASM:n jaettua muistia turvallisesti.

Yksinkertaisten luku- ja kirjoitusoperaatioiden lisäksi Atomics tarjoaa myös menetelmiä edistyneempään säikeiden synkronointiin:

• Atomics.wait(view, index, expectedValue, timeout): Sallii säikeen siirtyä lepotilaan (estää sen suorittamisen), kunnes tietty muistipaikka (view[index]) ei enää sisällä arvoa expectedValue tai aikakatkaisu tapahtuu.
• Atomics.notify(view, index, count): Herättää yhden tai useamman määritettyä muistipaikkaa odottavan säikeen.

Nämä ovat tehokkaita työkaluja monimutkaisten monisäikeisten rakenteiden, kuten tuottaja–kuluttaja-jonoiden, rakentamiseen. Niissä säikeiden on voitava pysähtyä ja jatkaa suoritusta jaetun datan muutosten perusteella.

Yhdistämällä SharedArrayBuffer-puskurin ja atomiset operaatiot voitte rakentaa vankkoja samanaikaisia sovelluksia. Esimerkkinä jaettu laskuri:

• JavaScript: Luo SharedArrayBuffer-puskurin ja Uint32Array-näkymän.
• Web Workers: Kukin worker vastaanottaa SharedArrayBuffer-puskurin ja alustaa WASM-moduulin.
• WASM Module: WASM-koodi (kuten Rust-esimerkkimme) käyttää atomisia operaatioita kasvattaakseen lineaarisen muistinsa tietyn indeksin arvoa. Muisti perustuu SharedArrayBuffer-puskuriin.

Tämä rakenne varmistaa, että vaikka useat säikeet kasvattaisivat laskuria nopeasti samanaikaisesti, lopullinen arvo on aina oikea eikä kilpailutilanteita synny.

Olemme tarkastelleet, kuinka SharedArrayBuffer mahdollistaa aidosti jaetun muistin JavaScript-säikeiden ja WebAssembly-moduulien välillä ja luo perustan monisäikeisille WASM-sovelluksille.

Opimme erityisesti, että atomiset operaatiot ovat välttämättömiä tämän jaetun muistin turvalliseen hallintaan. Ne estävät kilpailutilanteita ja varmistavat datan eheyden, kun useat säikeet käyttävät ja muokkaavat samaa dataa samanaikaisesti.

Näiden käsitteiden hallinta on olennaista rakennettaessa suorituskykyisiä ja luotettavia WebAssembly-sovelluksia, jotka hyödyntävät nykyaikaisten moniydinprosessorien koko tehoa.