Ciclo interprete virtual machine/byte code ottimale

Question

Il mio progetto ha una VM che esegue un codice byte compilato da un linguaggio specifico del dominio. Sto osservando i modi in cui posso migliorare il tempo di esecuzione del codice byte. Come primo passo vorrei vedere se c'è un modo per migliorare semplicemente l'interprete byte-code prima di entrare nella compilazione del codice macchina.

Il ciclo principale dell'interprete si presenta così:

while(true) 
{ 
    uint8_t cmd = *code++; 
    switch(cmd) 
    { 
    case op_1: ...; break; 
    ... 
    } 
} 

DOMANDA: C'è un modo più veloce per implementare questo ciclo senza ricorrere a Assembler?

L'unica opzione che vedo è GCC specifica per utilizzare goto dinamico con indirizzi di etichette. Piuttosto che un break alla fine di ogni caso, potrei passare direttamente all'istruzione successiva. Speravo che l'ottimizzatore avrebbe fatto questo per me, ma a quanto pare lo smontaggio non lo fa: c'è un salto costante ripetuto alla fine della maggior parte dei op_codes.

Se rilevante, la macchina virtuale è una macchina basata su registri semplice con registri in virgola mobile e interi (8 di ciascuno). Non c'è stack, solo un heap globale (quella lingua non è così complicata).

Answer 1

Uno molto semplice ottimizzazione è che invece di switch/case/caso/caso/caso/caso,

solo definire un array con puntatori a funzione (dove ogni funzione dovrebbe elaborare un comando specifico, o una coppia di comandi nel qual caso è possibile impostare diverse voci nella matrice per la stessa funzione, e la funzione stessa potrebbe verificare il codice esatto), invece di

switch(cmd) 

basta fare un

array[cmd]() 

Questo è dato che non si dispone di troppi comandi. Inoltre, fai qualche controllo se non definirai tutti i comandi possibili (forse hai solo 300 comandi, ma devi usare 2 byte per rappresentarli, quindi invece di definire un array con 65536 elementi, controlla se il comando è meno di 301 e se non lo è, non effettuare la ricerca)

Se non lo farai, ordina almeno i comandi che sono quelli più utilizzati all'inizio dell'istruzione switch.

Altrimenti sarebbe esaminare gli hashtable, ma presumo che non si abbiano molti comandi, e in tal caso l'overhead di eseguire una funzione di hash probabilmente ti costerà di più che non dover fare un passaggio. (Oppure hai una MOLTO funzione di hash semplice)

Answer 2

Qual è l'architettura? Potresti ottenere un'accelerazione con gli opcode con allineamento delle parole, ma questo farà esplodere le dimensioni del tuo codice, il che significa che dovrai bilanciarlo con il costo di una perdita della cache.

Answer 3

Pochi evidente ottimizzazione vedo sono,

1. Se non si utilizza cmd da nessuna parte che switch() quindi, utilizzare direttamente il riferimento indiretto puntatore, switch(*code++). Per un ciclo più lungo while(true), questo può essere poco utile.
2. In switch(), è possibile utilizzare continue anziché break.Perché quando continue viene utilizzato all'interno di if/else o switch, il compilatore sa che l'esecuzione deve passare al ciclo esterno; lo stesso non è vero per break (rispetto a switch). Spero che questo aiuti.