La microarchitettura

Nella pagina dedicata all'architettura di Neumann abbiamo guardato la macchina dalla balconata del piano superiore, con la memoria che conserva istruzioni e dati, il processore che preleva una parola dopo l'altra e il ciclo che prende, decodifica ed esegue senza mai fermarsi, e lì il contatore di programma, i registri di servizio e il set di istruzioni erano nomi del vocabolario, promesse di un meccanismo nascosto dietro il vetro. In questa pagina manteniamo la promessa e scendiamo di un piano intero, dal livello del set di istruzioni al livello di microarchitettura, dove le parole del vocabolario diventano gesti di elettronica e vediamo con esattezza come un ammasso di porte logiche, registri e bus riesca a eseguire davvero un'istruzione.

Dalla balconata il funzionamento sembrava una processione ordinata, perché il programma scorre dalla memoria verso la CPU, il contatore di programma tiene il segno dell'indirizzo della prossima istruzione, la decodifica sceglie la strada e l'esecuzione compie il calcolo o il trasporto richiesto, e ogni passo sembra richiedere un piccolo omino diligente che legga, capisca e agisca dentro il chip. Il punto delicato, e anche il più bello, è che dentro il processore non vive nessun omino, e nemmeno una mente che capisca il significato della parola istruzione, perché tutto ciò che esiste è una rete di fili che portano zeri e uno, registri che li trattengono per un istante e porte che li combinano, e la comprensione sta tutta nella coreografia, cioè nell'ordine preciso con cui questi pezzi vengono fatti muovere.

Per raccontare la coreografia ci affidiamo al capitolo quarto del libro di Tanenbaum, che costruisce una macchina didattica completa chiamata Mic-1 e le assegna un piccolo linguaggio da eseguire, l'IJVM, un sottoinsieme della macchina virtuale di Java ristretto ai numeri interi, e la scelta è azzeccata perché il modello è piccolo abbastanza da stare in una pagina e vero abbastanza da funzionare come una CPU reale, tanto che le CPU commerciali seguono gli stessi identici principi con altri numeri attaccati. Il nostro viaggio nasconde una sorpresa finale, perché chi segue il percorso con attenzione alla fine riesce a costruirsi da solo questo meccanismo dentro un simulatore, registro per registro e segnale per segnale.

L'idea che rende pensabile tutto questo è la stessa che guida il percorso fin dall'inizio, ed è che un calcolatore si costruisca a piani sovrapposti, come una casa nella quale ogni solaio poggia sul muro portante di quello sotto, con ogni piano che offre al piano superiore un linguaggio più comodo e che a sua volta si appoggia per i suoi servizi a quello inferiore. Il livello del set di istruzioni, che la pagina precedente ha descritto, è il piano in cui vivono le parole ADD, LOAD e STORE, e la microarchitettura è il piano portante subito sotto, il luogo concreto dove quelle parole vengono onorate con una sequenza di mosse fisiche, e proprio perché ogni piano è intercambiabile potrai un giorno costruire sotto lo stesso vocabolario un motore diverso, più veloce o più parsimonioso.

Il piano portante si divide in due metà che lavorano in coppia e si completano a vicenda, e conviene presentarle subito con le loro parti. La prima metà è il percorso dati, l'officina vera e propria, con i banchi da lavoro dove i valori attendono, i carrelli che li trasportano e l'unità aritmetica e logica che li lavora, e l'altra metà è l'unità di controllo, il capo officina che a ogni colpo di campanello ordina chi prende quale pezzo e chi lo consegna a chi, senza toccare mai i valori con le proprie mani. Tutta la pagina gira attorno a questa coppia, perché il percorso dati sa cosa si può fare e l'unità di controllo decide cosa si fa adesso.

Entriamo prima nell'officina. Il percorso dati del modello è fatto di registri a trentadue bit, i cassetti veloci che abbiamo imparato a costruire con i flip-flop nella pagina della logica sequenziale, e di due corridoi chiamati bus, il bus B che esce dai registri e il bus C che vi rientra, con in mezzo l'unità aritmetica e logica seguita da un circuito di scorrimento che sposta i bit di una posizione o di un byte quando serve. L'unità aritmetica è la stessa che abbiamo già imparato a conoscere nella pagina della logica digitale, capace di sommare, confrontare e combinare con le operazioni booleane, e il circuito di scorrimento aggiunge due movimenti utili, uno che fa scivolare il valore a sinistra di un byte intero e uno che lo sposta a destra di un bit ripetendo il segno, gesti che servono quando i programmi devono moltiplicare per numeri tondi o dimezzare con cura. All'inizio di ogni colpo di campanello un solo registro viene autorizzato a versare il proprio contenuto sul bus B, la ALU combina quel valore con quello che tiene fermo nel suo registro ausiliario, il risultato attraversa lo scorrimento e arriva sul bus C, e alla fine del colpo i registri scelti trangugiano ciò che il bus C porta loro.

Per parlare con la memoria esterna l'officina dispone di due porte distinte, e la distinzione merita un momento di attenzione perché spiega metà dei nomi misteriosi. La prima porta è larga trentadue bit e funziona a indirizzi di parola, così il registro MAR, il registro degli indirizzi di memoria, contiene la chiave del caveau, e il registro MDR, il registro dei dati di memoria, è il vassoio su cui la memoria depone la parola trovata o da cui l'officina prende la parola da conservare. La seconda porta è stretta otto bit e funziona a indirizzi di byte, ed è il mestiere della coppia PC e MBR, perché il contatore di programma indica il prossimo byte del flusso del programma e il registro MBR, il registro dei byte di memoria, riceve quel byte come un foglietto consegnato dal magazzino delle istruzioni.

Gli altri puntatori servono alla pila, di cui parleremo presto in dettaglio, e hanno ruoli che si capiscono meglio insieme. LV, il puntatore alle variabili locali, segna la base del blocco di memoria che appartiene alla procedura attiva in questo istante, e SP, il puntatore alla cima della pila, segna l'ultima parola occupata dello stesso blocco, così che se LV vale cento e la procedura ha tre variabili locali da quattro byte, SP vale centootto, e le variabili si chiamano per il loro spiazzamento rispetto a LV, come i cassetti di un banco che si contano a partire da un segno dipinto sul legno.

Completano la compagnia tre colleghi dai nomi altisonanti e un banco di lavoro. CPP è il puntatore alle costanti del programma, quella zona della memoria che conserva i numeri fissi, TOS è la copia di riserva del valore che sta in cima alla pila, tenuta a portata di mano perché la cima è il posto più trafficato dell'officina, e OPC è il ripostiglio dove il contatore di programma si ripone quando una procedura chiama un'altra procedura e ha bisogno di ricordare da dove era partito. H infine è il banco di lavoro personale della ALU, l'unico ingresso di sinistra che l'unità aritmetica accetta, e ogni calcolo che richiede due operandi deve prima far passare da lì almeno uno dei due.

Perché l'officina non cada nel caos, tutto avviene al ritmo di un orologio interno, il clock di cui abbiamo già parlato, e ogni colpo di campanello dura un ciclo del percorso dati diviso in quattro attimi, con i segnali che si impostano, il registro scelto che sale sul bus B, la ALU e lo scorrimento che lavorano, e infine i risultati che viaggiano sul bus C e vengono inghiottiti dai registri di destinazione esattamente sul colpo successivo del clock. Il bello è che nessun segnale esterno dice alla ALU quando lavorare né ordina ai risultati di entrare nel bus C, perché i confini dei quattro attimi esistono soltanto nei tempi di propagazione dei circuiti, e gli unici veri rintocchi sono la discesa del clock che apre il ciclo e la salita che chiude i cassetti. Questa scansione rigida spiega un trucco che a prima vista sembra impossibile, ed è che lo stesso registro può essere letto e riscritto dentro lo stesso ciclo, perché la lettura avviene nei primi attimi e la scrittura negli ultimi, e il valore vecchio ha già fatto il suo viaggio prima che quello nuovo lo sostituisca.

Vediamo ora il capo officina. L'unità di controllo esercita il suo potere attraverso fili chiamati segnali di controllo, ciascuno dei quali abilita un gesto preciso, per esempio quale registro versa sul bus B, quale registro trangugia dal bus C, quale funzione svolge la ALU e quando la memoria deve leggere o scrivere, e il nome tecnico delle tre mosse è semplice, leggi, scrivi e sposta, ripetute in combinazioni diverse milioni di volte al secondo. Il registro che tiene il passo di tutto questo si chiama MIR, il registro della microistruzione corrente, e i suoi bit sono questi fili, così che caricare una nuova parola nel MIR equivale a gridare all'officina l'ordine del prossimo istante.

Le parole da caricare nel MIR vivono in una memoria speciale chiamata memoria di controllo, diversa dalla memoria centrale che ospita programmi e dati, e nel modello contiene cinquecentododici parole da trentasei bit, una collezione che custodisce l'intero sapere motorio della macchina. Questa memoria viene letta in continuazione, senza bisogno di ordini di lettura o scrittura, perché il suo unico mestiere è consegnare a ogni colpo di campanello la parola puntata da MPC. Il registro MPC, il contatore del microprogramma, tiene l'indirizzo della parola corrente, con un nome buffo perché in realtà non conta quasi mai, dato che ogni microistruzione dice esplicitamente chi la segue, e a differenza delle istruzioni del programma, che nella memoria centrale vengono eseguite quasi sempre nel senso degli indirizzi crescenti, le ricette dello spartito saltano avanti e indietro per raggiungere la routine giusta con la mossa più breve. Due piccoli flip-flop chiamati N e Z ricordano rispettivamente se l'ultimo risultato della ALU è venuto negativo o nullo, e servono a decidere i salti condizionati, proprio come i flag di stato incontrati nei sommatori.

Ogni parola della memoria di controllo è una microistruzione, la vera ricetta elementare di questo piano, e la sua forma è un fascio di trentasei bit diviso in sei gruppi, come sei frasi di un ordine scritto. Quattro gruppi comandano l'officina con ventiquattro bit spartiti tra la funzione della ALU e dello scorrimento, il registro che sale sul bus B, i registri che si aprono verso il bus C e la memoria che legge o scrive, mentre i due gruppi rimasti decidono il futuro, e raccontarli in prosa ora conviene perché sono il cuore del meccanismo.

Il quinto gruppo, chiamato NEXT_ADDRESS, dice l'indirizzo della microistruzione successiva e il sesto, chiamato JAM, aggiusta quell'indirizzo nei casi speciali, con due bit che mescolano il valore ai flip-flop N e Z per compiere salti condizionati e con un terzo bit che sostituisce l'indirizzo con il contenuto del registro MBR per saltare alla routine dell'istruzione appena letta. L'intera collezione delle microistruzioni è il microprogramma, lo spartito completo dell'orchestra, nel quale ogni riga è una mossa elementare e il direttore è il clock che batte il tempo, e lo spartito che interpreta tutta la IJVM nel modello del libro conta appena centododici microistruzioni, una misura che dovresti tenere a mente per apprezzare quanto poco basti a far vivere un linguaggio intero. Per scrivere lo spartito senza impazzire sui singoli bit i progettisti usano un linguaggio simbolico che il libro chiama MAL, un dialetto assembler in cui ogni riga descrive le operazioni del percorso dati con assegnamenti leggibili e lascia a un microassemblatore il compito di tradurre le frasi nei trentasei bit veri, di assegnare gli indirizzi nella memoria di controllo e di trovare le coppie di indirizzi che il meccanismo dei salti condizionati richiede di allineare con cura.

Conosciamo ora il pezzo più celebre dello spartito, il ciclo che preleva dalla memoria la prossima istruzione, cioè il ciclo di prelievo che il libro compatta nella riga PC = PC + 1; fetch; goto (MBR). La prima mossa, eseguita dalla microistruzione che apre ogni giro, usa la porta stretta della memoria, perché il contenuto di PC scivola sul bus degli indirizzi del flusso di byte, la memoria riceve l'ordine di lettura e intanto, sullo stesso colpo di campanello, la ALU somma uno a PC e lo riscrive in se stesso, così il contatore avanza di un byte e si prepara già alla parola successiva mentre il magazzino cerca quella corrente.

La consegna richiede un ciclo intero, perché la memoria è lenta rispetto all'officina, e alla microistruzione seguente il byte prelevato si trova nel registro MBR. A quel punto il bit JMPC entra in azione e in MPC viene calcolato l'indirizzo di partenza della routine che implementa l'istruzione il cui codice operativo è proprio quel byte, così la memoria di controllo eroga la prima mossa della ricetta giusta e la macchina si impegna nell'esecuzione vera e propria. Ogni ricetta termina sempre con un salto di ritorno alla prima mossa del ciclo di prelievo, e questo giro senza fine, prendi poi esegui poi ricomincia, è il battito cardiaco di ogni processore von Neumann.

Per dare a questo battito qualcosa di concreto da eseguire serve un linguaggio, e il libro sceglie l'IJVM, una macchina didattica che prende dal linguaggio Java il modo di lavorare e se ne dimentica tutto il resto, tenendo soltanto i numeri interi e una manciata di istruzioni, il che la rende abbastanza piccola da poter essere raccontata riga per riga e abbastanza onesta da assomigliare alle macchine che esistevano sul serio. Ogni istruzione di questo linguaggio comincia con un codice operativo, un byte che dice di che parola si tratta, seguito quando serve da uno o due byte di operandi, e il tutto viaggia nel flusso che il contatore di programma esplora un byte alla volta.

La caratteristica che rende l'IJVM speciale è il suo modo di trattare i numeri, e per capirlo conviene pensare alla pila di piatti della mensa, nella quale ogni piatto nuovo si appoggia sopra gli altri e ogni piatto prelevato viene tolto sempre dalla cima, con l'ultimo arrivato che è il primo a partire. La struttura si chiama stack in inglese, pila, e le sue due mosse hanno nomi immediati, con il push che appoggia un valore in cima e il pop che solleva il valore che sta in cima, e tutta l'aritmetica di IJVM avviene in cima a questa pila, senza che nessuna istruzione debba dire dove si trovino i suoi numeri.

La pila della mensa ha in verità due ali nella memoria, e la distinzione serve a tenere in ordine il lavoro dei programmi. La prima ala, quella già raccontata, ospita le variabili locali delle procedure ed è sorvegliata dalla coppia LV e SP, che tracciano la base e la cima del blocco della procedura attiva. La seconda ala è lo stack degli operandi, il banco dove si svolgono i calcoli, e per sommare due numeri con questa organizzazione fai così, appoggi il primo operando in cima, appoggi il secondo sopra di esso e poi dai l'ordine di sommare, e l'istruzione di somma trova da sé i suoi due numeri proprio lì, li combina e lascia il risultato in cima, come un cameriere che trova i piatti pronti e sostituisce i due superiori con uno solo che contiene il totale.

Il vocabolario completo conta poche parole e vale la pena di sfogliarlo in ordine, perché ognuna è un piccolo gesto. ILOAD copia una variabile locale in cima alla pila e ISTORE riporta la cima nelle variabili locali, BIPUSH appoggia una costante piccola scritta dentro l'istruzione stessa e LDC_W pesca una costante grande dalla zona che CPP sorveglia, IADD e ISUB combinano i due valori in cima con la somma o la differenza, IAND e IOR fanno lo stesso con le operazioni logiche, IINC somma una costante a una variabile locale senza passare dalla pila, POP butta via la cima, DUP ne fa una fotocopia, SWAP scambia i due piatti più alti, GOTO sposta il flusso a un indirizzo nuovo, IFEQ, IFLT e IF_ICMPEQ lo spostano soltanto quando la condizione scritta nel nome si avvera, e INVOKEVIRTUAL con IRETURN aprono e chiudono le chiamate tra metodi, con WIDE che funge da prefisso per istruzioni dai numeri lunghi. Per fissare le idee considera il compitino che somma due variabili, che in Java si scrive come un assegnamento e in IJVM diventa la sequenza ILOAD di j, ILOAD di k, IADD e ISTORE in i, quattro parole che il libro traduce nei byte 0x15 per ILOAD, 0x60 per IADD e 0x36 per ISTORE, ognuna col suo numero di variabile attaccato.

Vediamo finalmente la traduzione nel motore, e cominciamo dall'istruzione IADD, la somma dei due valori in cima, che nel microprogramma del libro occupa esattamente tre mosse elementari. La prima mossa, scritta MAR = SP = SP-1; rd, fa scendere il puntatore di una parola e copia il risultato sia in SP che nel registro MAR, la chiave della memoria, mentre l'ordine rd chiede alla memoria di leggere, e il significato del gesto è che la nuova cima della pila, dove ora punta SP dopo la discesa, deve essere portata nell'officina perché lì giace il secondo operando della somma.

La seconda mossa, scritta H = TOS, è la più pigra da raccontare eppure indispensabile, perché copia nel banco di lavoro H il valore di riserva della cima della pila, cioè il primo operando, e da quel momento la ALU ha in mano entrambi i pezzi, il primo fermo in H e il secondo che viaggia nel registro MDR verso l'altro ingresso. La terza mossa, scritta MDR = TOS = MDR + H; wr; goto Main1, somma i due, deposita il risultato contemporaneamente in MDR e nella copia di riserva TOS, ordina alla memoria di riscrivere la parola alla posizione indicata da MAR, che è la nuova cima, e infine salta alla prima mossa del ciclo di prelievo, chiudendo il cerchio e lasciando la pila con un valore in meno e la somma al suo posto.

Il tutto merita un esempio con i numeri, così supponiamo che in cima alla pila ci sia il valore cinque e subito sotto il valore sette, con TOS che custodisce il cinque e SP che punta alla sua parola. La prima mossa fa scendere SP di una posizione e chiede la parola che trova, cioè il sette, la seconda mette il cinque in H, e la terza somma sette e cinque, riscrive dodici nella nuova cima e si conclude, così dopo un'unica istruzione del linguaggio IJVM la pila è scesa di un gradino e in cima troneggia il dodici, e per tutta questa operazione il processore ha speso tre microistruzioni, il che dà la misura del rapporto tra i piani, con una parola del vocabolario che vale sempre parecchie mosse del motore.

Che queste mosse vivano in una memoria e non in una rete fissa di porte è una scelta di progetto con conseguenze storiche enormi, e il confronto si racconta bene come un patto tra due virtù. L'idea di far eseguire le istruzioni da un interprete custodito in memoria risale agli anni cinquanta ed è legata al nome di Maurice Wilkes, mentre la sua vittoria commerciale più clamorosa arrivò alla fine di quegli anni, quando IBM progettò la famiglia System 360 come una sola architettura condivisa da macchine molto diverse per prezzo e prestazioni, e i modelli economici di quella famiglia onoravano lo stesso vocabolario proprio grazie a un interprete, dimostrando al mondo che un'officina semplice con un buon microprogramma poteva vestire gli abiti di una macchina gloriosa. Le implementazioni microprogrammate, come la Mic-1, conservano le ricette nella memoria di controllo e godono di una flessibilità rara, perché cambiando il contenuto di quella memoria la stessa officina impara a parlare un linguaggio diverso, il che ha permesso ai costruttori di correggere errori e di popolare le macchine di istruzioni complesse quasi gratis. Le implementazioni cablate invece traducono ogni istruzione in una rete di porte dedicata, e rinunciando a quella elasticità guadagnano velocità pura, dato che i segnali fluiscono senza attendere il caricamento di nessuna ricetta, e per decenni i progettisti hanno trattato esattamente su questo banco, con la flessibilità seduta da una parte e la velocità dall'altra.

La storia dei processori è anche la storia di questo patto. I primi calcolatori adottarono il microcodice senza chiamarlo con questo nome, poi negli anni settanta la moda degli insiemi di istruzioni ricchi e complessi, i CISC, rese il microprogramma lo strumento principe per domare vocabolari sterminati, e il modello del Pentium 4 raccontato dal libro interpreta ancora oggi le sue istruzioni più complicate con un microprogramma interno. Negli anni ottanta il movimento RISC ribaltò la valutazione e sposò il cablato, con istruzioni semplici pensate per concludersi in un singolo ciclo del percorso dati, lo stesso RISC che avevamo incontrato nella pagina precedente, e la lezione pratica è che entrambe le strade portano a macchine vere, purché il percorso dati e l'unità di controllo restino progettati in sintonia.

Con il modello in tasca puoi guardare le CPU reali con occhi nuovi, perché i nomi cambiano e i numeri si moltiplicano ma lo scheletro resta quello di questa pagina, con registri che versano sui bus, un'unità aritmetica al centro, una memoria di controllo oppure una rete cablata che detta i segnali e un ciclo di prelievo che gira senza sosta. Ed è qui che il progetto di ricostruzione di Tutanum tocca il suo cuore più profondo, perché chi ha compreso il percorso dati possiede lo strumento per costruirsene uno da solo dentro un simulatore, allineando flip-flop presi dalla pagina della logica, guidandoli con segnali e facendoli eseguire un microprogramma scritto da te, e quel giorno il computer che usi smetterà di essere una scatola magica per diventare una macchina che sai rifare con le mani.

Tutta l'attività che ti proponiamo ora si svolge sul divano del salotto o alla scrivania del computer, con carta, penna e programmi liberi, e non serve maneggiare corrente di sorta, così puoi dedicarle un pomeriggio intero senza correre alcun rischio, procedendo per prove successive dalla più semplice alla più articolata.

Per il primo esperimento cerca in rete un simulatore della Mic-1 o della IJVM, perché ne esistono parecchi gratuiti sia da scaricare sia da usare direttamente nel browser, avviane uno e carica il compitino della somma di due variabili raccontato poco sopra, poi eseguilo un passo alla volta premendo il tasto di avanzamento singolo e osserva con attenzione due attori, il registro PC che avanza di un byte alla volta nel flusso delle istruzioni e il registro SP che cresce quando i valori entrano nella pila e cala quando escono, e verifica con i tuoi occhi che la somma lasci in cima un solo valore, esattamente come promette il racconto.

Per il secondo esperimento torna alla carta e riesegui a mano il ciclo di prelievo, disegnando una tabellina con cinque colonne per PC, MAR, MDR, MBR e MPC e tre righe per i primi tre colpi di campanello, partendo da un PC qualsiasi che punta a un byte qualsiasi e aggiornando una colonna alla volta come ti ha insegnato la spiegazione, con PC che sale di uno alla prima riga, MBR che riceve il byte alla seconda e MPC che saltella all'indirizzo della routine alla terza. Quando la tabellina ti convince, riproduci la stessa sequenza nel simulatore del primo esperimento confrontando i valori a ogni passo, e festeggia la prima volta in cui il tuo foglio e la macchina dicono la stessa cosa.

Per il terzo esperimento prendi una penna e traduci da solo l'istruzione IADD in una sequenza di mosse elementari scritte in italiano piano, con frasi del tipo fai scendere il puntatore di uno, chiedi alla memoria la parola nuova, copia la cima nel banco di lavoro, somma e riscrivi il risultato, e quando hai finito confronta la tua versione con le tre microistruzioni del libro riportate più sopra, cercando di capire perché la prima mossa riesca a fare due cose insieme, calare SP e riempire MAR, e quale vantaggio questa doppia consegna regali al ciclo.

Per il quarto esperimento costruisci con le mani un pezzo vero del percorso dati dentro un simulatore di circuiti, per esempio quello libero di CircuitVerse già incontrato nella pagina della logica digitale, allineando otto flip-flop del tipo che hai studiato per formare un registro a otto bit, aggiungendo un ingresso di comando che permetta di scriverli tutti nello stesso istante e un'uscita che versi il contenuto su un bus condiviso. Comanda poi il tuo registro con due interruttori, uno per l'ordine di scrittura e uno per l'ordine di uscita, e gusta la sensazione precisa di aver costruito con le tue mani virtuali uno dei cassetti dell'officina che questa pagina ha raccontato.

Per il quinto esperimento installa un emulatore di una CPU vecchia a otto bit, perché le macchine degli anni settanta e ottanta sono abbastanza lente e trasparenti da mostrare i propri organi, carica un programmino già pronto oppure una delle tante raccolte di esempi e caccia l'elenco dei registri che l'emulatore mostra durante l'esecuzione, dove riconoscerai come vecchie conoscenze il contatore di programma che avanza, il puntatore della pila che respira, i registri ausiliari che si scambiano valori e persino il registro di stato con i suoi bit N e Z, gli stessi nomi che il libro dà alla Mic-1 con altri abiti addosso.

Per il sesto e ultimo esperimento mettiti alla ricerca in rete della descrizione di una microarchitettura didattica, dato che parecchi corsi universitari pubblicano liberamente documenti che riprendono il modello della Mic-1 con varianti proprie, e leggine uno con gli occhi di chi ora capisce il mestiere, segnandoti in un angolo del foglio quante microistruzioni servono per eseguire l'istruzione più semplice del linguaggio e come vengono chiamati nei documenti il percorso dati e la memoria di controllo, così da accorgerti che le parole che hai imparato qui viaggiano da un testo all'altro come passaporti riconosciuti.

Quello che hai letto in questa pagina attinge al capitolo quarto del libro Architettura dei calcolatori di Andrew S. Tanenbaum, alla sezione che costruisce il percorso dati con i suoi registri e i suoi bus, alla sezione che presenta l'insieme d'istruzioni IJVM con la sua pila di operandi, e alla sezione che chiude il cerchio implementando ogni istruzione come microcodice nella memoria di controllo, il tutto tradotto in prosa piano con le analogie dell'officina e della partitura. Ora che sai come il motore esegue davvero ogni parola del vocabolario, il piano successivo del percorso sale di nuovo verso la luce e ti presenta quel vocabolario in prima persona, con le sue convenzioni, le sue scritture mnemoniche e i suoi traduttori, motivo per cui la prossima pagina è dedicata all'architettura del set di istruzioni e all'assembler e puoi raggiungerla da qui quando ti senti pronto.