Estruturas de Dados Lock-Free com SharedArrayBuffer em JavaScript: Operações Atómicas

No domínio do desenvolvimento web moderno e de ambientes JavaScript do lado do servidor como o Node.js, a necessidade de uma programação concorrente eficiente está em constante crescimento. À medida que as aplicações se tornam mais complexas e exigem maior desempenho, os desenvolvedores exploram cada vez mais técnicas para aproveitar múltiplos núcleos e threads. Uma ferramenta poderosa para alcançar isso em JavaScript é o SharedArrayBuffer, combinado com operações Atomics, que permite a criação de estruturas de dados lock-free.

Introdução à Concorrência em JavaScript

Tradicionalmente, o JavaScript é conhecido como uma linguagem de thread único. Isso significa que apenas uma tarefa pode ser executada de cada vez dentro de um determinado contexto de execução. Embora isso simplifique muitos aspetos do desenvolvimento, também pode ser um gargalo para tarefas computacionalmente intensivas. Os Web Workers fornecem uma maneira de executar código JavaScript em threads de segundo plano, mas a comunicação entre workers tem sido tradicionalmente assíncrona e envolvia a cópia de dados.

O SharedArrayBuffer muda isso ao fornecer uma região de memória que pode ser acedida por múltiplos threads simultaneamente. No entanto, este acesso compartilhado introduz o potencial para condições de corrida e corrupção de dados. É aqui que os Atomics entram em cena. Os Atomics fornecem um conjunto de operações atómicas que garantem que as operações na memória compartilhada sejam realizadas de forma indivisível, evitando a corrupção de dados.

Entendendo o SharedArrayBuffer

SharedArrayBuffer é um objeto JavaScript que representa um buffer de dados binários brutos de comprimento fixo. Ao contrário de um ArrayBuffer regular, um SharedArrayBuffer pode ser compartilhado entre múltiplos threads (Web Workers) sem exigir a cópia explícita dos dados. Isso permite uma verdadeira concorrência com memória compartilhada.

Exemplo: Criando um SharedArrayBuffer

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

            

              
                Copy
              
            
          

Para aceder aos dados dentro do SharedArrayBuffer, é necessário criar uma visualização de array tipado, como Int32Array ou Float64Array:

            
const int32View = new Int32Array(sab);

            

              
                Copy
              
            
          

Isso cria uma visualização Int32Array sobre o SharedArrayBuffer, permitindo que você leia e escreva inteiros de 32 bits na memória compartilhada.

O Papel do Atomics

Atomics é um objeto global que fornece operações atómicas. Estas operações garantem que as leituras e escritas na memória compartilhada sejam realizadas atomicamente, prevenindo condições de corrida. Elas são cruciais para a construção de estruturas de dados lock-free que podem ser acedidas de forma segura por múltiplos threads.

Principais Operações Atómicas:

• Atomics.load(typedArray, index): Lê um valor do índice especificado no array tipado.
• Atomics.store(typedArray, index, value): Escreve um valor no índice especificado no array tipado.
• Atomics.add(typedArray, index, value): Adiciona um valor ao valor no índice especificado.
• Atomics.sub(typedArray, index, value): Subtrai um valor do valor no índice especificado.
• Atomics.exchange(typedArray, index, value): Substitui o valor no índice especificado por um novo valor e retorna o valor original.
• Atomics.compareExchange(typedArray, index, expectedValue, newValue): Compara o valor no índice especificado com um valor esperado. Se forem iguais, o valor é substituído por um novo valor. Retorna o valor original.
• Atomics.wait(typedArray, index, expectedValue, timeout): Espera que um valor no índice especificado mude de um valor esperado.
• Atomics.wake(typedArray, index, count): Acorda um número especificado de waiters que estão à espera de um valor no índice especificado.

Estas operações são fundamentais para a construção de algoritmos lock-free.

Construindo Estruturas de Dados Lock-Free

Estruturas de dados lock-free são estruturas de dados que podem ser acedidas por múltiplos threads concorrentemente sem o uso de locks. Isso elimina a sobrecarga e os potenciais deadlocks associados aos mecanismos de bloqueio tradicionais. Usando SharedArrayBuffer e Atomics, podemos implementar várias estruturas de dados lock-free em JavaScript.

1. Contador Lock-Free

Um exemplo simples é um contador lock-free. Este contador pode ser incrementado e decrementado por múltiplos threads sem quaisquer locks.

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

// Exemplo de uso em dois 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();
}

// Após a conclusão de ambos os workers (usando um mecanismo como Promise.all para garantir a conclusão)
// counter.getValue() deve ser próximo de 0. O resultado real pode variar devido à concorrência

            

              
                Copy
              
            
          

2. Pilha Lock-Free

Um exemplo mais complexo é uma pilha lock-free. Esta pilha usa uma estrutura de lista encadeada armazenada no SharedArrayBuffer e operações atómicas para gerir o ponteiro da cabeça.

            
class LockFreeStack {
  constructor(capacity) {
    this.capacity = capacity;
    // Cada nó requer espaço para um valor e um ponteiro para o próximo nó
    // Aloca espaço para os nós e um ponteiro da cabeça
    this.buffer = new SharedArrayBuffer((capacity + 1) * 2 * Int32Array.BYTES_PER_ELEMENT); // Valor e ponteiro Próximo para cada nó + Ponteiro da Cabeça
    this.view = new Int32Array(this.buffer);

    this.headIndex = capacity * 2; // índice onde o ponteiro da cabeça é armazenado
    Atomics.store(this.view, this.headIndex, -1); // Inicializa a cabeça como nula (-1)

    // Inicializa os nós com seus ponteiros 'next' para reutilização posterior.
    for (let i = 0; i < capacity; i++) {
      const nextIndex = (i === capacity - 1) ? -1 : i + 1; // o último nó aponta para nulo
      this.setNext(i, nextIndex);
    }

    this.freeListHead = 0; // Inicializa a cabeça da lista livre para o primeiro nó
  }

  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; // tenta pegar da lista livre
    if (nodeIndex === -1) {
      return false; // estouro da pilha
    }

    let nextFree = this.getNext(nodeIndex);
    // tenta atualizar atomicamente a cabeça da lista livre para nextFree. Se falharmos, alguém já a pegou.
    if (Atomics.compareExchange(this.view, this.capacity*2, nodeIndex, nextFree) !== nodeIndex) {
        return false; // tenta novamente se houver contenção
    }

    // temos um nó, escrevemos o valor nele
    this.setValue(nodeIndex, value);

    let head;
    let newHead = nodeIndex;

    do {
      head = Atomics.load(this.view, this.headIndex);
      this.setNext(newHead, head);
      // Compara-e-troca a cabeça com newHead. Se falhar, significa que outra thread fez push nesse meio tempo
    } while (Atomics.compareExchange(this.view, this.headIndex, head, newHead) !== head);

    return true; // sucesso
  }

  pop() {
    let head = Atomics.load(this.view, this.headIndex);
    if (head === -1) {
      return undefined; // a pilha está vazia
    }

    let next = this.getNext(head);
    // Tenta atualizar a cabeça para o próximo. Se falhar, significa que outra thread fez pop nesse meio tempo
    if (Atomics.compareExchange(this.view, this.headIndex, head, next) !== head) {
      return undefined; // tenta novamente, ou indica falha.
    }

    const value = this.getValue(head);

    // Retorna o nó para a lista livre.
    let currentFreeListHead = this.freeListHead;
    do {
        this.setNext(head, currentFreeListHead); // aponta o nó liberado para a lista livre atual
    } while(Atomics.compareExchange(this.view, this.capacity*2, currentFreeListHead, head) !== currentFreeListHead);

    return value; // sucesso
  }
}

// Exemplo de Uso (em um worker):
const stack = new LockFreeStack(1024); // Cria uma pilha com 1024 elementos

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

//desempilhando
const value1 = stack.pop(); // Valor 20
const value2 = stack.pop(); // Valor 10


            

              
                Copy
              
            
          

3. Fila Lock-Free

Construir uma fila lock-free envolve a gestão atómica dos ponteiros de cabeça e cauda. Isto é mais complexo do que a pilha, mas segue princípios semelhantes usando Atomics.compareExchange.

Nota: Uma implementação detalhada de uma fila lock-free seria mais extensa e está para além do âmbito desta introdução, mas envolveria conceitos semelhantes aos da pilha, gerindo cuidadosamente a memória e usando operações CAS (Compare-and-Swap) para garantir um acesso concorrente seguro.

Benefícios das Estruturas de Dados Lock-Free

• Desempenho Melhorado: A eliminação de locks reduz a sobrecarga e evita a contenção, levando a um maior débito.
• Prevenção de Deadlocks: Os algoritmos lock-free são inerentemente livres de deadlocks, uma vez que não dependem de locks.
• Concorrência Aumentada: Permite que mais threads acedam à estrutura de dados concorrentemente sem se bloquearem mutuamente.

Desafios e Considerações

• Complexidade: A implementação de algoritmos lock-free pode ser complexa e propensa a erros. Requer um profundo entendimento de concorrência e modelos de memória.
• Problema ABA: O problema ABA ocorre quando um valor muda de A para B e depois de volta para A. Uma operação de comparação e troca pode ter sucesso incorretamente, levando à corrupção de dados. As soluções para o problema ABA geralmente envolvem a adição de um contador ao valor que está a ser comparado.
• Gerenciamento de Memória: É necessário um gerenciamento de memória cuidadoso para evitar fugas de memória e garantir a alocação e desalocação adequadas de recursos. Podem ser usadas técnicas como ponteiros de perigo ou recuperação baseada em épocas.
• Depuração: A depuração de código concorrente pode ser desafiadora, pois os problemas podem ser difíceis de reproduzir. Ferramentas como depuradores e profilers podem ser úteis.

Exemplos Práticos e Casos de Uso

As estruturas de dados lock-free podem ser usadas em vários cenários onde alta concorrência e baixa latência são necessárias:

• Desenvolvimento de Jogos: Gerir o estado do jogo e sincronizar dados entre múltiplos threads do jogo.
• Sistemas de Tempo Real: Processar fluxos de dados e eventos em tempo real.
• Servidores de Alto Desempenho: Lidar com pedidos concorrentes e gerir recursos compartilhados.
• Processamento de Dados: Processamento paralelo de grandes conjuntos de dados.
• Aplicações Financeiras: Realizar negociações de alta frequência e cálculos de gestão de risco.

Exemplo: Processamento de Dados em Tempo Real numa Aplicação Financeira

Imagine uma aplicação financeira que processa dados do mercado de ações em tempo real. Múltiplos threads precisam de aceder e atualizar estruturas de dados compartilhadas que representam preços de ações, livros de ordens e posições de negociação. Usando estruturas de dados lock-free, a aplicação pode lidar eficientemente com o alto volume de dados recebidos e garantir a execução atempada das negociações.

Compatibilidade do Navegador e Segurança

SharedArrayBuffer e Atomics são amplamente suportados nos navegadores modernos. No entanto, devido a preocupações de segurança relacionadas com as vulnerabilidades Spectre e Meltdown, os navegadores inicialmente desativaram o SharedArrayBuffer por padrão. Para reativá-lo, geralmente é necessário definir os seguintes cabeçalhos de resposta HTTP:

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

            

              
                Copy
              
            
          

Estes cabeçalhos isolam a sua origem, impedindo a fuga de informações entre origens. Certifique-se de que o seu servidor está configurado corretamente para enviar estes cabeçalhos ao servir código JavaScript que usa SharedArrayBuffer.

Alternativas ao SharedArrayBuffer e Atomics

Embora SharedArrayBuffer e Atomics forneçam ferramentas poderosas para a programação concorrente, existem outras abordagens:

• Passagem de Mensagens: Usar a passagem de mensagens assíncrona entre Web Workers. Esta é uma abordagem mais tradicional, mas envolve a cópia de dados entre threads.
• Threads WebAssembly (WASM): O WebAssembly também suporta memória compartilhada e operações atómicas, que podem ser usadas para construir aplicações concorrentes de alto desempenho.
• Service Workers: Embora principalmente para caching e tarefas de segundo plano, os service workers também podem ser usados para processamento concorrente usando passagem de mensagens.

A melhor abordagem depende dos requisitos específicos da sua aplicação. SharedArrayBuffer e Atomics são mais adequados quando precisa compartilhar grandes quantidades de dados entre threads com sobrecarga mínima e sincronização rigorosa.

Melhores Práticas

• Mantenha a Simplicidade: Comece com algoritmos lock-free simples e aumente gradualmente a complexidade conforme necessário.
• Testes Exaustivos: Teste exaustivamente o seu código concorrente para identificar e corrigir condições de corrida e outros problemas de concorrência.
• Revisões de Código: Peça a desenvolvedores experientes e familiarizados com programação concorrente que revejam o seu código.
• Use Ferramentas de Profiling de Desempenho: Use ferramentas de profiling de desempenho para identificar gargalos e otimizar o seu código.
• Documente o Seu Código: Documente claramente o seu código para explicar o design e a implementação dos seus algoritmos lock-free.

Conclusão

SharedArrayBuffer e Atomics fornecem um mecanismo poderoso para construir estruturas de dados lock-free em JavaScript, permitindo uma programação concorrente eficiente. Embora a complexidade da implementação de algoritmos lock-free possa ser desafiadora, os potenciais benefícios de desempenho são significativos para aplicações que requerem alta concorrência e baixa latência. À medida que o JavaScript continua a evoluir, estas ferramentas tornar-se-ão cada vez mais importantes para a construção de aplicações escaláveis e de alto desempenho. Adotar estas técnicas, juntamente com uma forte compreensão dos princípios de concorrência, capacita os desenvolvedores a ultrapassar os limites do desempenho do JavaScript num mundo multi-core.

Recursos Adicionais para Aprendizagem

• MDN Web Docs: SharedArrayBuffer
• MDN Web Docs: Atomics
• Artigos sobre estruturas de dados e algoritmos lock-free.
• Publicações de blog e artigos sobre programação concorrente em JavaScript.