JavaScript SharedArrayBuffer låsfrie datastrukturer: Atomiske operasjoner

I en verden av moderne webutvikling og server-side JavaScript-miljøer som Node.js, øker behovet for effektiv samtidig programmering stadig. Ettersom applikasjoner blir mer komplekse og krever høyere ytelse, utforsker utviklere i økende grad teknikker for å utnytte flere kjerner og tråder. Et kraftig verktøy for å oppnå dette i JavaScript er SharedArrayBuffer, kombinert med Atomics-operasjoner, som muliggjør opprettelsen av låsfrie datastrukturer.

Introduksjon til samtidighet i JavaScript

Tradisjonelt har JavaScript vært kjent som et entrådet språk. Dette betyr at bare én oppgave kan utføres om gangen innenfor en gitt kjøringskontekst. Selv om dette forenkler mange aspekter ved utvikling, kan det også være en flaskehals for beregningsintensive oppgaver. Web Workers gir en måte å kjøre JavaScript-kode i bakgrunnstråder, men kommunikasjonen mellom workers har tradisjonelt vært asynkron og involvert kopiering av data.

SharedArrayBuffer endrer dette ved å tilby et minneområde som kan aksesseres av flere tråder samtidig. Denne delte tilgangen introduserer imidlertid potensialet for race conditions og datakorrupsjon. Det er her Atomics kommer inn i bildet. Atomics tilbyr et sett med atomiske operasjoner som garanterer at operasjoner på delt minne utføres udelelig, og forhindrer dermed datakorrupsjon.

Forståelse av SharedArrayBuffer

SharedArrayBuffer er et JavaScript-objekt som representerer en rå binær databuffer med fast lengde. I motsetning til en vanlig ArrayBuffer, kan en SharedArrayBuffer deles mellom flere tråder (Web Workers) uten å kreve eksplisitt kopiering av dataene. Dette muliggjør ekte samtidighet med delt minne.

Eksempel: Opprette en SharedArrayBuffer

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

            

              
                Copy
              
            
          

For å få tilgang til dataene i SharedArrayBuffer, må du opprette en typet array-visning, som Int32Array eller Float64Array:

            
const int32View = new Int32Array(sab);

            

              
                Copy
              
            
          

Dette oppretter en Int32Array-visning over SharedArrayBuffer, som lar deg lese og skrive 32-bits heltall til det delte minnet.

Rollen til Atomics

Atomics er et globalt objekt som tilbyr atomiske operasjoner. Disse operasjonene garanterer at lesing og skriving til delt minne utføres atomisk, noe som forhindrer race conditions. De er avgjørende for å bygge låsfrie datastrukturer som trygt kan aksesseres av flere tråder.

Viktige atomiske operasjoner:

• Atomics.load(typedArray, index): Leser en verdi fra den angitte indeksen i det typede arrayet.
• Atomics.store(typedArray, index, value): Skriver en verdi til den angitte indeksen i det typede arrayet.
• Atomics.add(typedArray, index, value): Legger til en verdi til verdien på den angitte indeksen.
• Atomics.sub(typedArray, index, value): Trekker en verdi fra verdien på den angitte indeksen.
• Atomics.exchange(typedArray, index, value): Erstatter verdien på den angitte indeksen med en ny verdi og returnerer den opprinnelige verdien.
• Atomics.compareExchange(typedArray, index, expectedValue, newValue): Sammenligner verdien på den angitte indeksen med en forventet verdi. Hvis de er like, erstattes verdien med en ny verdi. Returnerer den opprinnelige verdien.
• Atomics.wait(typedArray, index, expectedValue, timeout): Venter på at en verdi på den angitte indeksen skal endres fra en forventet verdi.
• Atomics.wake(typedArray, index, count): Vekker et spesifisert antall ventende tråder som venter på en verdi på den angitte indeksen.

Disse operasjonene er fundamentale for å bygge låsfrie algoritmer.

Bygge låsfrie datastrukturer

Låsfrie datastrukturer er datastrukturer som kan aksesseres av flere tråder samtidig uten bruk av låser. Dette eliminerer overhead og potensielle vranglåser (deadlocks) forbundet med tradisjonelle låsemekanismer. Ved å bruke SharedArrayBuffer og Atomics kan vi implementere ulike låsfrie datastrukturer i JavaScript.

1. Låsfri teller

Et enkelt eksempel er en låsfri teller. Denne telleren kan økes og reduseres av flere tråder uten låser.

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

// Eksempel på bruk i to web workers
const counter = new LockFreeCounter();

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

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

// Etter at begge workers er ferdige (ved hjelp av en mekanisme som Promise.all for å sikre fullføring)
// counter.getValue() bør være nær 0. Faktisk resultat kan variere på grunn av samtidighet

            

              
                Copy
              
            
          

2. Låsfri stabel

Et mer komplekst eksempel er en låsfri stabel. Denne stabelen bruker en lenket listestruktur lagret i SharedArrayBuffer og atomiske operasjoner for å administrere hodepekeren.

            
class LockFreeStack {
  constructor(capacity) {
    this.capacity = capacity;
    // Hver node krever plass til en verdi og en peker til neste node
    // Alloker plass for noder og en hodepeker
    this.buffer = new SharedArrayBuffer((capacity + 1) * 2 * Int32Array.BYTES_PER_ELEMENT); // Verdi & Neste-peker for hver node + Hodepeker
    this.view = new Int32Array(this.buffer);

    this.headIndex = capacity * 2; // indeks der hodepekeren er lagret
    Atomics.store(this.view, this.headIndex, -1); // Initialiser hodet til null (-1)

    // Initialiser nodene med deres 'neste'-pekere for senere gjenbruk.
    for (let i = 0; i < capacity; i++) {
      const nextIndex = (i === capacity - 1) ? -1 : i + 1; // siste node peker til null
      this.setNext(i, nextIndex);
    }

    this.freeListHead = 0; // Initialiser hodet til den ledige listen til den første noden
  }

  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; // prøv å hente fra den ledige listen
    if (nodeIndex === -1) {
      return false; // stack overflow
    }

    let nextFree = this.getNext(nodeIndex);
    // prøv atomisk å oppdatere hodet på den ledige listen til nextFree. Hvis vi mislykkes, har noen andre allerede tatt den.
    if (Atomics.compareExchange(this.view, this.capacity*2, nodeIndex, nextFree) !== nodeIndex) {
        return false; // prøv igjen ved konflikt
    }

    // vi har en node, skriv verdien inn i den
    this.setValue(nodeIndex, value);

    let head;
    let newHead = nodeIndex;

    do {
      head = Atomics.load(this.view, this.headIndex);
      this.setNext(newHead, head);
      // Sammenlign-og-bytt hode med newHead. Hvis det mislykkes, betyr det at en annen tråd har pushet i mellomtiden
    } while (Atomics.compareExchange(this.view, this.headIndex, head, newHead) !== head);

    return true; // suksess
  }

  pop() {
    let head = Atomics.load(this.view, this.headIndex);
    if (head === -1) {
      return undefined; // stabelen er tom
    }

    let next = this.getNext(head);
    // Prøv å oppdatere hodet til neste. Hvis det mislykkes, betyr det at en annen tråd har poppet i mellomtiden
    if (Atomics.compareExchange(this.view, this.headIndex, head, next) !== head) {
      return undefined; // prøv igjen, eller indiker feil.
    }

    const value = this.getValue(head);

    // Returner noden til den ledige listen.
    let currentFreeListHead = this.freeListHead;
    do {
        this.setNext(head, currentFreeListHead); // pek frigjort node til gjeldende ledige liste
    } while(Atomics.compareExchange(this.view, this.capacity*2, currentFreeListHead, head) !== currentFreeListHead);

    return value; // suksess
  }
}

// Eksempel på bruk (i en worker):
const stack = new LockFreeStack(1024); // Opprett en stabel med 1024 elementer

//legger til
stack.push(10);
stack.push(20);

//henter ut
const value1 = stack.pop(); // Verdi 20
const value2 = stack.pop(); // Verdi 10


            

              
                Copy
              
            
          

3. Låsfri kø

Å bygge en låsfri kø innebærer å administrere både hode- og halepekere atomisk. Dette er mer komplekst enn stabelen, men følger lignende prinsipper ved hjelp av Atomics.compareExchange.

Merk: En detaljert implementering av en låsfri kø ville vært mer omfattende og er utenfor rammen for denne introduksjonen, men ville involvert lignende konsepter som stabelen, med nøye minnehåndtering og bruk av CAS (Compare-and-Swap)-operasjoner for å garantere sikker samtidig tilgang.

Fordeler med låsfrie datastrukturer

• Forbedret ytelse: Å eliminere låser reduserer overhead og unngår konflikter, noe som fører til høyere gjennomstrømning.
• Unngåelse av vranglåser: Låsfrie algoritmer er i seg selv fri for vranglåser (deadlocks) siden de ikke er avhengige av låser.
• Økt samtidighet: Lar flere tråder få tilgang til datastrukturen samtidig uten å blokkere hverandre.

Utfordringer og hensyn

• Kompleksitet: Implementering av låsfrie algoritmer kan være komplekst og utsatt for feil. Krever en dyp forståelse av samtidighet og minnemodeller.
• ABA-problemet: ABA-problemet oppstår når en verdi endres fra A til B og deretter tilbake til A. En sammenlign-og-bytt-operasjon kan feilaktig lykkes, noe som fører til datakorrupsjon. Løsninger på ABA-problemet innebærer ofte å legge til en teller til verdien som sammenlignes.
• Minnehåndtering: Nøye minnehåndtering er nødvendig for å unngå minnelekkasjer og sikre riktig allokering og deallokering av ressurser. Teknikker som 'hazard pointers' eller epokebasert gjenvinning kan brukes.
• Debugging: Debugging av samtidig kode kan være utfordrende, da problemer kan være vanskelige å reprodusere. Verktøy som debuggere og profilere kan være nyttige.

Praktiske eksempler og bruksområder

Låsfrie datastrukturer kan brukes i ulike scenarioer der høy samtidighet og lav latens er påkrevd:

• Spillutvikling: Håndtering av spilltilstand og synkronisering av data mellom flere spilltråder.
• Sanntidssystemer: Behandling av sanntids datastrømmer og hendelser.
• Høyytelsesservere: Håndtering av samtidige forespørsler og delte ressurser.
• Databehandling: Parallellprosessering av store datasett.
• Finansielle applikasjoner: Utføring av høyfrekvent handel og risikostyringsberegninger.

Eksempel: Sanntids databehandling i en finansiell applikasjon

Se for deg en finansiell applikasjon som behandler sanntidsdata fra aksjemarkedet. Flere tråder må få tilgang til og oppdatere delte datastrukturer som representerer aksjekurser, ordrebøker og handelsposisjoner. Ved å bruke låsfrie datastrukturer kan applikasjonen effektivt håndtere den høye mengden innkommende data og sikre rettidig utførelse av handler.

Nettleserkompatibilitet og sikkerhet

SharedArrayBuffer og Atomics er bredt støttet i moderne nettlesere. På grunn av sikkerhetsbekymringer knyttet til Spectre- og Meltdown-sårbarhetene, deaktiverte nettlesere imidlertid SharedArrayBuffer som standard. For å re-aktivere det, må du vanligvis sette følgende HTTP-responshoder:

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

            

              
                Copy
              
            
          

Disse hoderne isolerer din opprinnelse (origin), og forhindrer informasjonslekkasje på tvers av opprinnelser. Sørg for at serveren din er riktig konfigurert til å sende disse hoderne når den serverer JavaScript-kode som bruker SharedArrayBuffer.

Alternativer til SharedArrayBuffer og Atomics

Selv om SharedArrayBuffer og Atomics gir kraftige verktøy for samtidig programmering, finnes det andre tilnærminger:

• Meldingsutveksling: Bruk av asynkron meldingsutveksling mellom Web Workers. Dette er en mer tradisjonell tilnærming, men innebærer kopiering av data mellom tråder.
• WebAssembly (WASM) Threads: WebAssembly støtter også delt minne og atomiske operasjoner, som kan brukes til å bygge høytytende samtidige applikasjoner.
• Service Workers: Selv om de primært er for caching og bakgrunnsoppgaver, kan service workers også brukes til samtidig behandling ved hjelp av meldingsutveksling.

Den beste tilnærmingen avhenger av de spesifikke kravene til applikasjonen din. SharedArrayBuffer og Atomics er best egnet når du trenger å dele store mengder data mellom tråder med minimal overhead og streng synkronisering.

Beste praksis

• Hold det enkelt: Start med enkle låsfrie algoritmer og øk kompleksiteten gradvis etter behov.
• Grundig testing: Test den samtidige koden grundig for å identifisere og fikse race conditions og andre samtidighetsproblemer.
• Kodegjennomgang: Få koden din gjennomgått av erfarne utviklere som er kjent med samtidig programmering.
• Bruk ytelsesprofilering: Bruk verktøy for ytelsesprofilering for å identifisere flaskehalser og optimalisere koden din.
• Dokumenter koden din: Dokumenter koden tydelig for å forklare designet og implementeringen av dine låsfrie algoritmer.

Konklusjon

SharedArrayBuffer og Atomics tilbyr en kraftig mekanisme for å bygge låsfrie datastrukturer i JavaScript, noe som muliggjør effektiv samtidig programmering. Selv om kompleksiteten ved å implementere låsfrie algoritmer kan være avskrekkende, er de potensielle ytelsesfordelene betydelige for applikasjoner som krever høy samtidighet og lav latens. Ettersom JavaScript fortsetter å utvikle seg, vil disse verktøyene bli stadig viktigere for å bygge høytytende, skalerbare applikasjoner. Å omfavne disse teknikkene, sammen med en solid forståelse av prinsipper for samtidighet, gir utviklere mulighet til å flytte grensene for JavaScript-ytelse i en verden med flere kjerner.

Ressurser for videre læring

• MDN Web Docs: SharedArrayBuffer
• MDN Web Docs: Atomics
• Artikler om låsfrie datastrukturer og algoritmer.
• Blogginnlegg og artikler om samtidig programmering i JavaScript.