La differenza tra architettura CPU basata su accumulatore e registro basata?

Un'architettura CPU basata su registro ha uno o più registri di uso generale (in cui "registro generale" esclude i registri di scopi speciali, come il puntatore dello stack e il puntatore di istruzioni).

Un'architettura CPU basata su accumulatore è un'architettura CPU basata su registro che ha solo un registro generale (l'accumulatore).

Il vantaggio / i principale di "più che un registro generale" è che il compilatore non deve "versare" tanti valori temporanei nello stack; ed è più facile per la CPU eseguire più istruzioni indipendenti in parallelo.

Per un esempio, immagina di voler fare a = (b - c) + (d - f) + 123 . Per un confronto "mele vs mele" userò l'assembly 80x86 di 32-bit della sintassi Intel per entrambi gli esempi (ma uso EAX solo per l'architettura CPU basata su accumulator).

Per l'architettura CPU basata su accumulatore, può essere:

    mov eax,[b]     ;Group 1

    sub eax,[c]     ;Group 2

    add eax,123     ;Group 3

    mov [a],eax     ;Group 4
    mov eax,[d]

    sub eax,[e]     ;Group 5

    add [a],eax     ;Group 6

Si noti che la maggior parte di queste istruzioni dipende dal risultato dell'istruzione precedente e pertanto non può essere eseguita in parallelo. I commenti "; Gruppo N" sono lì per indicare quali gruppi di istruzioni possono essere eseguiti in parallelo (e mostrare che, assumendo una qualche forma di abilità interna di "rinominazione del registro", "gruppo 4" è l'unico gruppo in cui 2 istruzioni sono suscettibili di essere fatto in parallelo).

L'uso di più registri potrebbe darti:

    mov eax,[b]           ;Group 1
    mov ebx,[d]

    sub eax,[c]           ;Group 2
    sub ebx,[e]

    lea eax,[eax+ebx+123] ;Group 3        

    mov [a],eax           ;Group 4

In questo caso, c'è un'istruzione in meno e 2 in meno gruppi di istruzioni (più istruzioni possibili eseguite in parallelo). Ciò potrebbe significare "25% più veloce" nella pratica.

Naturalmente in pratica il codice fa più di un calcolo relativamente semplice; quindi c'è ancora più possibilità di "più istruzioni in parallelo". Per esempio; con solo 2 registri in più (ad esempio ECX ed EDX) dovrebbe essere facile vedere che si potrebbe fare a = (b - c) + (d - f) + 123 e g = (h - i) + (j - k) + 456 nello stesso intervallo di tempo (eseguendo entrambi i calcoli in parallelo con registri diversi); e dovrebbe anche essere facile vedere che per l'architettura CPU basata su accumulatore non è possibile eseguire i calcoli in parallelo (due calcoli richiederebbero il doppio del tempo di un calcolo).

Nota: c'è almeno una "potenziale inesattezza tecnica" in ciò che ho scritto qui (che riguarda principalmente le capacità teoriche della ridenominazione dei registri e la sua applicazione su architetture CPU basate su accumulator). Questo è intenzionale. Trovo che entrare troppo nel dettaglio (nel tentativo di essere "100% tecnicamente corretto" e coprire tutti i piccoli casi d'angolo) rende molto più difficile per le persone capire le parti rilevanti.

La differenza, secondo me, è nel modo in cui gli operandi sono specificati.

A un'estremità dello spettro, un'architettura di registro può supportare la specifica di tutti e tre gli operandi per operazioni binarie come add - cioè: input 1 & 2 e destinazione dell'output, mentre un altro può consentire di specificare solo due operandi e fino all'estremo opposto può supportare solo un operando esplicito. (Il design dello stack è ancora più estremo, specificando none se gli operandi!)

Molte architetture mescoleranno una, due e / o tre istruzioni operative binarie operando (ad esempio, aggiungi) nel loro ISA, rendendo più difficile caratterizzare l'architettura nel suo complesso, quindi dovremmo esaminare più le singole istruzioni.

I trade off di base sono la dimensione delle istruzioni rispetto alla possibilità di riutilizzare i calcoli intermedi. Nello stile usando meno operandi specificati, le codifiche delle istruzioni sono più brevi, ma i risultati sovrascrivono gli operandi sorgente, limitando al contempo anche altre opzioni.

Per alcune sequenze di codice, a volte due istruzioni di operando richiedono l'uso di due istruzioni per ottenere gli stessi risultati di una istruzione a tre operandi. Per altre sequenze di codice,  entrambi prendono lo stesso numero di istruzioni, il che significa che meno versioni di operando avranno come risultato un'istruzione potenzialmente più breve.

Per esempio, diciamo che abbiamo valori nei registri A e B. Per aggiungerli usando una forma a due operandi, o aggiungiamo A in B - distruggendo B, o B in A (distruggendo A) Se questa sovrascrittura / la distruzione è, ok, allora va bene. Ma se no, dobbiamo copiare un operando (ad esempio A) per registrare C, quindi aggiungere B a C - due istruzioni!

Un'istruzione a tre registri sarebbe stata in grado di aggiungere A a B in C senza distruggere nessuna sorgente di input.

Nell'accumulatore, le operazioni vengono eseguite tramite l'interazione con il registro dell'accumulatore in ogni fase del percorso. Ad esempio, (a + b) - d è Fatto come, metti a in accum, aggiungi b all'accumulo, il valore dell'accumulatore ora contiene la somma di a e b. Successivamente sottrarre d da accum dà il risultato finale. Per operazioni complesse c'è un significativo sacrificio di tempo. Mentre il registro basato può memorizzare i valori nei singoli registri e le operazioni possono essere tra registri. Quindi (a + b) -d implica mettere un in reg x, mettere b in reg y, inserire d in reg Z. Aggiungere X e y. Sottrai Z. Questo è più conveniente e genera codice più corto in programmi complessi. Risparmia tempo.

Le differenze pratiche tra l'accumulatore e le architetture basate sul registro sono le seguenti:

basato su accumulatore: il codice è più piccolo e viene eseguito più lentamente.

basato su registro: il codice è più grande e viene eseguito più velocemente.