JavaScript: das closures aos sistemas autônomos

Capítulo 7. Execução especulativa

Parte II. Uma máquina que aprende a executar código8 min

07

Execução especulativa

Em 1992, Urs Hölzle, Craig Chambers e David Ungar estavam resolvendo um problema que não tinha nada a ver com velocidade. O compilador do Self já tinha aprendido a otimizar programas tão bem que deles quase nada sobrava no código de máquina. Funções se dissolviam dentro de outras funções, variáveis viviam em registradores ou sumiam de vez, e quando o programador parava o programa no depurador não havia nada para mostrar a ele: o programa que ele tinha escrito simplesmente não existia na memória. Abrir mão das otimizações dava pena, e o depurador sem elas funcionava como uma televisão com o cabo arrancado.

Os autores do Self inventaram um jeito de desdobrar o código otimizado de volta, sob demanda. Em pontos escolhidos de antemão, o compilador deixava um bilhete dizendo onde estava naquele momento cada variável do programa original. Quando o depurador parava num desses pontos, o sistema remontava pelo bilhete o quadro da função na forma que o programador esperava e continuava a execução já em código não otimizado. Só a função que estava sendo examinada no depurador era desdobrada, e todo o resto continuava rodando em velocidade máxima. O artigo se chamava «Depuração de código otimizado com desotimização dinâmica», e a palavra «desotimização», que vimos nos logs do V8 nos primeiros capítulos, vem de lá.

Quinze anos depois, essa saída de emergência inventada para o depurador virou o principal motor da velocidade. Se o motor pode, a qualquer momento, largar o código otimizado e voltar a um código que comprovadamente se comporta segundo a especificação, então dá para otimizar pelo caso provável, mesmo sem garantias. Sem saída de emergência, o compilador é obrigado a considerar todos os casos, até os que nunca vão acontecer. Com ela, pode arriscar à vontade, desde que haja uma verificação em cada curva.


Pegue uma função que soma os números de um array:

function sum(arr) {
  let s = 0;
  for (let i = 0; i < arr.length; i++) s += arr[i];
  return s;
}

Enquanto a função roda no interpretador, ele anota a cada operação o que passou por ela. O V8 mantém para isso uma tabela separada para cada função, com uma linha para cada soma, cada leitura de campo e cada chamada. Digamos que sum só recebeu arrays de inteiros pequenos. O V8 guarda esses números dentro da própria referência, sem objeto separado na memória, e eles cabem em 31 bits. Quando a função é entregue ao compilador inteligente, ele lê a tabela e raciocina como um apostador que tem estatísticas. Já que no array sempre houve inteiros pequenos, dá para somá-los com uma única instrução inteira do processador, sem verificar se aquilo é número, se é fracionário ou se é string. Resta pôr duas verificações pequenas: que o array continua feito de inteiros pequenos e que a soma não passou de 31 bits. Cada verificação dessas é uma bifurcação em que um caminho segue pelo código rápido e o outro leva à saída, à desotimização.

Grátis, só falta um passo

O resto do livro é grátis

Deixe seu e-mail e eu mando um link para confirmar. Depois do clique, todos os capítulos abrem aqui, neste aparelho, por um ano. Quando sair um livro novo, escrevo para esse endereço; responda “parar” a qualquer e-mail e não escrevo mais.

Tem conta INITE? Entre, e o livro abre sem e-mail.

O livro não custa nada. Se quiser apoiá-lo, dá para fazer uma doação a partir de qualquer capítulo.

Como o endereço é guardado