Experimentos · JavaScript: das closures aos sistemas autônomos · Capítulo 7

Uma cadeia de apostas perdidas

Otimização especulativa e desotimização no V8

Tema
ExperimenteUma cadeia de apostas perdidas
A função sum do capítulo passa por cinco fases no seu próprio navegador: inteiros pequenos, grandes, decimais, strings e inteiros pequenos de novo. Depois de cada fase aparece quanto custa uma chamada aqui e quanto custou no livro, e no fim quantas vezes ficaram mais lentos os mesmos dados do começo.

Tudo é calculado no seu navegador; nada é enviado.

Sobre este experimento

O que é desotimização no V8?

Desotimização é o que o V8 faz quando perde uma aposta do seu compilador otimizador. Enquanto a função roda no interpretador, o V8 anota os tipos que passam por cada operação. O compilador otimizador gera código de máquina supondo que esses tipos vão continuar os mesmos e coloca uma verificação onde a suposição pode falhar. Quando uma verificação falha, por exemplo uma soma de inteiros transborda ou um array muda o tipo dos seus elementos, o código de máquina é descartado e a execução volta ao interpretador. Depois a função é otimizada de novo, com a informação de tipos mais ampla que ela juntou até ali.

Um motor como o V8 primeiro roda a função no interpretador e anota o que passa por ela. Quando a função esquenta, o compilador otimizador lê essas anotações e aposta que o futuro vai se parecer com o passado. Se o array sempre teve inteiros pequenos, ele os soma com uma única instrução do processador e deixa duas verificações: que os elementos continuam inteiros pequenos e que a soma ainda cabe em 31 bits. Uma verificação que falha é uma aposta perdida, e o motor volta ao interpretador.

Aperte o botão de fase cinco vezes. A mesma sum() recebe um array de mil inteiros pequenos, depois inteiros grandes cuja soma passa de 31 bits, depois decimais, depois strings e por fim os inteiros pequenos do começo. Cada fase é aquecida com 3000 chamadas, como no livro, e depois medida no seu próprio motor. O último botão roda uma cópia nova da função só com inteiros pequenos, para comparar.

No livro, no Node 24, uma chamada custava 0,46–0,50 µs na primeira fase, 0,92–1,04 µs depois do transbordamento, 0,79 µs com decimais e 4,5–5,3 µs com strings. O V8 registrou overflow na segunda fase e wrong map em cada uma das três seguintes. A última fase levou 1,83–2,46 µs, de quatro a cinco vezes mais que a primeira com os mesmos dados.

O capítulo chama isso de cadeia de apostas perdidas. O motor lembra de tudo o que a função recebeu, e depois de inteiros, decimais e strings a informação dele diz que o próximo valor pode ser qualquer coisa, então o código reotimizado sai genérico e mais lento. A velocidade de uma função depende do que ela recebeu antes, e o texto do programa não mostra isso.

Do livro

JavaScript: das closures aos sistemas autônomos · Capítulo 7

Execução especulativa

Ao lado deste experimento no capítulo
Na última etapa a função volta a receber os mesmos inteiros pequenos com que tudo começou, e aí se descobre que o motor guarda rancor. A chamada agora leva cerca de dois microssegundos, de quatro a cinco vezes mais que no início, embora os dados sejam os mesmos. A tabela do motor lembra tudo o que passou pela função: inteiros, fracionários, strings. O compilador inteligente a lê e desta vez joga na defensiva, constrói um código pronto para tudo, e um código assim é mais lento. Se você rodar a última etapa num processo novo, ela volta a levar meio microssegundo. A velocidade da função agora depende do que lhe deram antes, e o motor enganado, como uma pessoa decepcionada algumas vezes, demora muito para devolver a confiança de antes.