Eu li recentemente a pergunta aquiPor que é mais rápido processar uma matriz classificada do que uma matriz não classificada? e achei a resposta absolutamente fascinante e mudou completamente minha perspectiva de programação ao lidar com ramificações baseadas em dados.

Eu atualmente tenho um interpretado Intel 8080 Emulator interpretado em C, o coração da operação é uma tabela de 256 casos de comutação para lidar com cada opcode. Meu pensamento inicial foi que este seria obviamente o método mais rápido de trabalhar, pois a codificação opcode não é consistente em todo o conjunto de instruções do 8080 e a decodificação adicionaria muita complexidade, inconsistência e casos únicos. Uma tabela de casos de comutação cheia de macros pré-processador é muito simples e fácil de manter.

Infelizmente, depois de ler o post mencionado anteriormente, ocorreu-me que não há absolutamente nenhuma maneira de o preditor de ramificação em meu computador prever o salto para o switch case. Assim, toda vez que o switch case for navegado, o pipeline teria que ser completamente limpo, resultando em um atraso de vários ciclos no que, de outra forma, seria um programa incrivelmente rápido (não há nem mesmo a multiplicação no meu código).

Tenho certeza que a maioria de vocês está pensando "Oh, a solução aqui é simples, vá para a recompilação dinâmica". Sim, isso parece que cortaria a maioria do switch case e aumentaria consideravelmente a velocidade. Infelizmente, meu principal interesse é emular consoles de era de 8 e 16 bits (a intel 8080 aqui é apenas um exemplo, pois é minha parte mais simples de código emulado), onde o ciclo e o tempo de manter a instrução exata são importantes, como Vídeo e Som. deve ser processado com base nesses horários exatos.

Ao lidar com esse nível de precisão, o desempenho se torna um problema, mesmo para consoles mais antigos (veja o bSnes, por exemplo). Existe algum recurso ou isso é simplesmente uma questão de fato ao lidar com processadores com longos pipelines?