JavaScript SharedArrayBuffer lukuvabad andmestruktuurid: atomaarsed operatsioonid

Kaasaegse veebiarenduse ja serveripoolsete JavaScripti keskkondade, nagu Node.js, valdkonnas kasvab pidevalt vajadus tõhusa rööptöötluse järele. Kuna rakendused muutuvad keerukamaks ja nõuavad suuremat jõudlust, uurivad arendajad üha enam tehnikaid mitme tuuma ja lõime ärakasutamiseks. Üks võimas vahend selle saavutamiseks JavaScriptis on SharedArrayBuffer koos Atomics operatsioonidega, mis võimaldab luua lukuvabu andmestruktuure.

Sissejuhatus rööptöötlusesse JavaScriptis

Traditsiooniliselt on JavaScripti tuntud kui ühelõimelist keelt. See tähendab, et antud täitmiskontekstis saab korraga täita ainult ühte ülesannet. Kuigi see lihtsustab paljusid arendusaspekte, võib see olla ka pudelikaelaks arvutusmahukate ülesannete puhul. Veebitöötajad (Web Workers) pakuvad võimalust JavaScripti koodi käivitada taustalõimedes, kuid suhtlus töötajate vahel on traditsiooniliselt olnud asünkroonne ja hõlmanud andmete kopeerimist.

SharedArrayBuffer muudab seda, pakkudes mälu piirkonda, millele pääsevad samaaegselt juurde mitu lõime. See jagatud juurdepääs tekitab aga potentsiaali võidujooksutingimusteks (race conditions) ja andmete rikkumiseks. Siin tulevadki mängu Atomics operatsioonid. Atomics pakub komplekti atomaarseid operatsioone, mis tagavad, et toimingud jagatud mälus teostatakse jagamatult, vältides andmete rikkumist.

SharedArrayBufferi mõistmine

SharedArrayBuffer on JavaScripti objekt, mis esindab fikseeritud pikkusega toorest binaarandmete puhvrit. Erinevalt tavalisest ArrayBuffer'ist saab SharedArrayBuffer'it jagada mitme lõime (veebitöötajate) vahel, ilma et oleks vaja andmeid selgesõnaliselt kopeerida. See võimaldab tõelist jagatud mäluga rööptöötlust.

Näide: SharedArrayBufferi loomine

            
const sab = new SharedArrayBuffer(1024); // 1KB SharedArrayBuffer

            

              
                Copy
              
            
          

SharedArrayBuffer'i andmetele juurdepääsemiseks peate looma tüübistatud massiivi vaate, näiteks Int32Array või Float64Array:

            
const int32View = new Int32Array(sab);

            

              
                Copy
              
            
          

See loob Int32Array vaate üle SharedArrayBuffer'i, võimaldades teil lugeda ja kirjutada 32-bitiseid täisarve jagatud mällu.

Atomics'i roll

Atomics on globaalne objekt, mis pakub atomaarseid operatsioone. Need operatsioonid tagavad, et lugemised ja kirjutamised jagatud mälus teostatakse atomaarselt, vältides võidujooksutingimusi. Need on hädavajalikud lukuvabade andmestruktuuride ehitamiseks, millele mitu lõime saavad ohutult juurde pääseda.

Põhilised atomaarsed operatsioonid:

• Atomics.load(typedArray, index): Loeb väärtuse tüübistatud massiivi määratud indeksilt.
• Atomics.store(typedArray, index, value): Kirjutab väärtuse tüübistatud massiivi määratud indeksile.
• Atomics.add(typedArray, index, value): Liidab väärtuse määratud indeksil olevale väärtusele.
• Atomics.sub(typedArray, index, value): Lahutab väärtuse määratud indeksil olevast väärtusest.
• Atomics.exchange(typedArray, index, value): Asendab määratud indeksil oleva väärtuse uue väärtusega ja tagastab algse väärtuse.
• Atomics.compareExchange(typedArray, index, expectedValue, newValue): Võrdleb määratud indeksil olevat väärtust oodatud väärtusega. Kui need on võrdsed, asendatakse väärtus uue väärtusega. Tagastab algse väärtuse.
• Atomics.wait(typedArray, index, expectedValue, timeout): Ootab, kuni määratud indeksil olev väärtus muutub oodatud väärtusest erinevaks.
• Atomics.wake(typedArray, index, count): Äratab kindla arvu ootajaid, kes ootavad väärtust määratud indeksil.

Need operatsioonid on lukuvabade algoritmide ehitamisel fundamentaalsed.

Lukuvabade andmestruktuuride ehitamine

Lukuvabad andmestruktuurid on andmestruktuurid, millele mitu lõime saavad samaaegselt juurde pääseda ilma lukke kasutamata. See välistab traditsiooniliste lukustusmehhanismidega seotud lisakulu ja võimalikud ummikseisud (deadlocks). Kasutades SharedArrayBuffer'it ja Atomics'it, saame JavaScriptis implementeerida erinevaid lukuvabu andmestruktuure.

1. Lukuvaba loendur

Lihtne näide on lukuvaba loendur. Seda loendurit saavad mitu lõime suurendada ja vähendada ilma lukkudeta.

            
class LockFreeCounter {
  constructor() {
    this.buffer = new SharedArrayBuffer(Int32Array.BYTES_PER_ELEMENT);
    this.view = new Int32Array(this.buffer);
  }

  increment() {
    Atomics.add(this.view, 0, 1);
  }

  decrement() {
    Atomics.sub(this.view, 0, 1);
  }

  getValue() {
    return Atomics.load(this.view, 0);
  }
}

// Näide kasutamisest kahes veebitöötajas
const counter = new LockFreeCounter();

// Töötaja 1
for (let i = 0; i < 1000; i++) {
  counter.increment();
}

// Töötaja 2
for (let i = 0; i < 1000; i++) {
  counter.decrement();
}

// Pärast mõlema töötaja lõpetamist (kasutades mehhanismi nagu Promise.all, et tagada lõpetamine)
// counter.getValue() peaks olema 0 lähedal. Tegelik tulemus võib rööptöötluse tõttu erineda

            

              
                Copy
              
            
          

2. Lukuvaba magasin (stack)

Keerulisem näide on lukuvaba magasin (stack). See magasin kasutab SharedArrayBuffer'is talletatud seotud loendi struktuuri ja atomaarseid operatsioone pea viida haldamiseks.

            
class LockFreeStack {
  constructor(capacity) {
    this.capacity = capacity;
    // Iga sõlm nõuab ruumi väärtuse ja järgmise sõlme viida jaoks
    // Eralda ruumi sõlmedele ja pea viidale
    this.buffer = new SharedArrayBuffer((capacity + 1) * 2 * Int32Array.BYTES_PER_ELEMENT); // Väärtus & Järgmise viit iga sõlme jaoks + Pea viit
    this.view = new Int32Array(this.buffer);

    this.headIndex = capacity * 2; // indeks, kus hoitakse pea viita
    Atomics.store(this.view, this.headIndex, -1); // Initsialiseeri pea nulliks (-1)

    // Initsialiseeri sõlmed nende 'next' viitadega hilisemaks taaskasutamiseks.
    for (let i = 0; i < capacity; i++) {
      const nextIndex = (i === capacity - 1) ? -1 : i + 1; // viimane sõlm viitab nullile
      this.setNext(i, nextIndex);
    }

    this.freeListHead = 0; // Initsialiseeri vabade sõlmede loendi pea esimese sõlmega
  }

  setNext(nodeIndex, nextIndex) {
     this.view[nodeIndex * 2 + 1] = nextIndex;
  }

  getNext(nodeIndex) {
     return this.view[nodeIndex * 2 + 1];
  }

  getValue(nodeIndex) {
    return this.view[nodeIndex * 2];
  }

  setValue(nodeIndex, value){ 
      this.view[nodeIndex*2] = value;
  }

  push(value) {
    let nodeIndex = this.freeListHead; // proovi võtta vabade loendist
    if (nodeIndex === -1) {
      return false; // magasin on täis
    }

    let nextFree = this.getNext(nodeIndex);
    // proovi atomaarselt uuendada vabade loendi pea väärtuseks nextFree. Kui ebaõnnestub, võttis keegi teine selle juba.
    if (Atomics.compareExchange(this.view, this.capacity*2, nodeIndex, nextFree) !== nodeIndex) {
        return false; // proovi uuesti, kui esineb konkurents
    }

    // meil on sõlm, kirjuta väärtus sinna sisse
    this.setValue(nodeIndex, value);

    let head;
    let newHead = nodeIndex;

    do {
      head = Atomics.load(this.view, this.headIndex);
      this.setNext(newHead, head);
      // Võrdle-ja-vaheta (Compare-and-swap) pea väärtusega newHead. Kui see ebaõnnestub, tähendab see, et teine lõim lisas vahepeal midagi
    } while (Atomics.compareExchange(this.view, this.headIndex, head, newHead) !== head);

    return true; // õnnestus
  }

  pop() {
    let head = Atomics.load(this.view, this.headIndex);
    if (head === -1) {
      return undefined; // magasin on tühi
    }

    let next = this.getNext(head);
    // Proovi uuendada pea väärtuseks next. Kui see ebaõnnestub, tähendab see, et teine lõim eemaldas vahepeal midagi
    if (Atomics.compareExchange(this.view, this.headIndex, head, next) !== head) {
      return undefined; // proovi uuesti või teata ebaõnnestumisest.
    }

    const value = this.getValue(head);

    // Tagasta sõlm vabade loendisse.
    let currentFreeListHead = this.freeListHead;
    do {
        this.setNext(head, currentFreeListHead); // suuna vabanenud sõlm praegusele vabade loendile
    } while(Atomics.compareExchange(this.view, this.capacity*2, currentFreeListHead, head) !== currentFreeListHead);

    return value; // õnnestus
  }
}

// Kasutusnäide (töötajas):
const stack = new LockFreeStack(1024); // Loo magasin 1024 elemendiga

//lisamine
stack.push(10);
stack.push(20);

//eemaldamine
const value1 = stack.pop(); // Väärtus 20
const value2 = stack.pop(); // Väärtus 10


            

              
                Copy
              
            
          

3. Lukuvaba järjekord (queue)

Lukuvaba järjekorra ehitamine hõlmab nii pea- kui ka sabaviida atomaarset haldamist. See on keerulisem kui magasin, kuid järgib sarnaseid põhimõtteid, kasutades Atomics.compareExchange'i.

Märkus: Lukuvaba järjekorra detailne implementatsioon oleks ulatuslikum ja jääb selle sissejuhatuse raamest välja, kuid see hõlmaks sarnaseid kontseptsioone nagu magasini puhul, hallates hoolikalt mälu ja kasutades CAS (Compare-and-Swap) operatsioone, et tagada ohutu samaaegne juurdepääs.

Lukuvabade andmestruktuuride eelised

• Parem jõudlus: Lukkude kaotamine vähendab lisakulu ja väldib konkurentsi, mis viib suurema läbilaskevõimeni.
• Ummikseisude vältimine: Lukuvabad algoritmid on olemuslikult ummikseisuvabad, kuna need ei tugine lukkudele.
• Suurenenud rööptöötlus: Võimaldab rohkematel lõimededel andmestruktuurile samaaegselt juurde pääseda, ilma üksteist blokeerimata.

Väljakutsed ja kaalutlused

• Keerukus: Lukuvabade algoritmide implementeerimine võib olla keeruline ja vigaderohke. Nõuab sügavat arusaamist rööptöötlusest ja mälu mudelitest.
• ABA probleem: ABA probleem tekib siis, kui väärtus muutub A-st B-ks ja seejärel tagasi A-ks. Võrdle-ja-vaheta operatsioon võib valesti õnnestuda, mis viib andmete rikkumiseni. ABA probleemi lahendused hõlmavad sageli loenduri lisamist võrreldavale väärtusele.
• Mäluhaldus: Hoolikas mäluhaldus on vajalik mälulekete vältimiseks ning ressursside nõuetekohase eraldamise ja vabastamise tagamiseks. Kasutada võib tehnikaid nagu ohutusviidad (hazard pointers) või epohhipõhine taastamine.
• Silumine (debugging): Rööptöötluskoodi silumine võib olla keeruline, kuna probleeme on raske reprodutseerida. Tööriistad nagu silurid ja profiilijad võivad olla abiks.

Praktilised näited ja kasutusjuhud

Lukuvabu andmestruktuure saab kasutada erinevates stsenaariumides, kus on vaja suurt rööptöötlust ja madalat latentsust:

• Mänguarendus: Mängu oleku haldamine ja andmete sünkroniseerimine mitme mängulõime vahel.
• Reaalajasüsteemid: Reaalajas andmevoogude ja sündmuste töötlemine.
• Suure jõudlusega serverid: Samaaegsete päringute käsitlemine ja jagatud ressursside haldamine.
• Andmetöötlus: Suurte andmekogumite paralleeltöötlus.
• Finantsrakendused: Kõrgsagedusliku kauplemise ja riskijuhtimise arvutuste teostamine.

Näide: reaalajas andmetöötlus finantsrakenduses

Kujutage ette finantsrakendust, mis töötleb reaalajas aktsiaturu andmeid. Mitmed lõimed peavad pääsema juurde ja uuendama jagatud andmestruktuure, mis esindavad aktsiahindu, orderiraamatuid ja kauplemispositsioone. Kasutades lukuvabu andmestruktuure, saab rakendus tõhusalt hakkama suure hulga sissetulevate andmetega ja tagada tehingute õigeaegse täitmise.

Brauseri ühilduvus ja turvalisus

SharedArrayBuffer ja Atomics on kaasaegsetes brauserites laialdaselt toetatud. Kuid Spectre'i ja Meltdowni haavatavustega seotud turvaprobleemide tõttu lülitasid brauserid algselt SharedArrayBuffer'i vaikimisi välja. Selle uuesti lubamiseks peate tavaliselt seadistama järgmised HTTP vastuse päised:

            
Cross-Origin-Embedder-Policy: require-corp
Cross-Origin-Opener-Policy: same-origin

            

              
                Copy
              
            
          

Need päised isoleerivad teie päritolu, vältides päritoluülest teabeleket. Veenduge, et teie server on õigesti konfigureeritud saatma neid päiseid, kui serveerite JavaScripti koodi, mis kasutab SharedArrayBuffer'it.

Alternatiivid SharedArrayBufferile ja Atomicsile

Kuigi SharedArrayBuffer ja Atomics pakuvad võimsaid tööriistu rööptöötluseks, on olemas ka teisi lähenemisviise:

• Sõnumite edastamine: Asünkroonse sõnumite edastamise kasutamine veebitöötajate vahel. See on traditsioonilisem lähenemine, kuid hõlmab andmete kopeerimist lõimede vahel.
• WebAssembly (WASM) lõimed: WebAssembly toetab samuti jagatud mälu ja atomaarseid operatsioone, mida saab kasutada suure jõudlusega rööptöötlusrakenduste ehitamiseks.
• Teenindustöötajad (Service Workers): Kuigi peamiselt vahemällu salvestamiseks ja taustatoiminguteks, saab teenindustöötajaid kasutada ka rööptöötluseks sõnumite edastamise kaudu.

Parim lähenemine sõltub teie rakenduse konkreetsetest nõuetest. SharedArrayBuffer ja Atomics sobivad kõige paremini siis, kui peate jagama suuri andmemahte lõimede vahel minimaalse lisakulu ja range sünkroniseerimisega.

Parimad praktikad

• Hoidke see lihtsana: Alustage lihtsate lukuvabade algoritmidega ja suurendage keerukust järk-järgult vastavalt vajadusele.
• Põhjalik testimine: Testige oma rööptöötluskoodi põhjalikult, et tuvastada ja parandada võidujooksutingimusi ja muid rööptöötlusprobleeme.
• Koodiülevaatused: Laske oma kood üle vaadata kogenud arendajatel, kes on kursis rööptöötlusega.
• Kasutage jõudluse profiilimist: Kasutage jõudluse profiilimise tööriistu, et tuvastada pudelikaelu ja optimeerida oma koodi.
• Dokumenteerige oma kood: Dokumenteerige oma kood selgelt, et selgitada oma lukuvabade algoritmide disaini ja implementatsiooni.

Kokkuvõte

SharedArrayBuffer ja Atomics pakuvad võimsat mehhanismi lukuvabade andmestruktuuride ehitamiseks JavaScriptis, võimaldades tõhusat rööptöötlust. Kuigi lukuvabade algoritmide implementeerimise keerukus võib olla hirmutav, on potentsiaalsed jõudluse eelised märkimisväärsed rakenduste jaoks, mis nõuavad suurt rööptöötlust ja madalat latentsust. Kuna JavaScript areneb edasi, muutuvad need tööriistad üha olulisemaks suure jõudlusega ja skaleeritavate rakenduste ehitamisel. Nende tehnikate omaksvõtmine koos rööptöötluse põhimõtete tugeva mõistmisega annab arendajatele võimaluse nihutada JavaScripti jõudluse piire mitmetuumalises maailmas.

Täiendavad õppematerjalid

• MDN Web Docs: SharedArrayBuffer
• MDN Web Docs: Atomics
• Teadusartiklid lukuvabade andmestruktuuride ja algoritmide kohta.
• Blogipostitused ja artiklid rööptöötlusest JavaScriptis.