Little man computer
Il Little Man Computer (LMC, letteralmente L'omino-computer) è un modello di computer a istruzioni, creato dal dottor Stuart Madnick nel 1965.[1] Viene generalmente usato come mezzo di istruzione, perché rappresenta un semplice computer con Architettura di von Neumann, la base di ogni computer contemporaneo. Può essere programmato sia in linguaggio macchina sia in linguaggio Assembly.[2][3][4]
Architettura di sistema[modifica | modifica wikitesto]
L'idea di base del LMC è la seguente: si immagina un omino chiuso in una stanzetta (o direttamente dentro il computer). Da un lato della stanza, ci sono 100 buche delle lettere (che rappresentano la memoria del computer), numerate da 0 a 99. Ognuna di esse può contenere un'istruzione oppure un dato, codificati con 3 caratteri numerici, dal valore 000 al valore 999. Dall'altro lato della stanza ci sono invece due ulteriori buche delle lettere, chiamate INBOX e OUTBOX, usate per ricevere dati e trasmetterli in uscita. Al centro della stanza c'è una sorta di scrivania da lavoro con un calcolatrice che ha solo due semplici funzioni: addizione e sottrazione. La calcolatrice rappresenta l'accumulatore. Assieme alla calcolatrice è presente un contatore azzerabile, che rappresenta il Program Counter. Il Program Counter contiene l'indirizzo della prossima istruzione che l'Omino dovrà portare a termine. In condizioni normali, non appena tale istruzione viene eseguita, il Program Counter viene incrementato di 1: in questo modo l'Omino svolgerà tutte le istruzioni in sequenza. È però possibile attraverso istruzioni di salto codificare istruzioni di iterazione (cicli), o anche strutture di selezione condizionata del tipo if-else, queste ultime semplicemente settando il Program Counter a una specifica istruzione se qualche particolare condizione è verificata, ad esempio se il valore mostrato dalla calcolatrice è zero oppure è positivo. Proprio come nell'Architettura di von Neumann, la memoria contiene sia istruzioni sia dati, bisogna quindi fare attenzione a fermare il contatore quando si raggiunge un indirizzo contenente dei dati, o l'Omino li considererà istruzioni e tenterà di trattarli come tali. Per utilizzare l'LMC, l'utente immette dei dati nelle buche delle lettere e poi segnala all'Omino di cominciare l'esecuzione. L'Omino comincerà dall'istruzione contenuta nell'indirizzo di memoria numero zero: in questo modo, resettando il Program Counter a zero si riavvia il programma.
Ciclo d'esecuzione[modifica | modifica wikitesto]
Per eseguire un programma, l'Omine svolge i seguenti passi:
- Guarda il Program Counter per capire quale buca delle lettere contiene l'istruzione da eseguire (ad esempio, la numero zero)
- recupera l'istruzione dalla buca con il numero corrispondente
- incrementa il Program Counter, in questo modo esso conterrà il numero dell'istruzione seguente
- decodifica l'istruzione, ottenendo anche il numero delle buche delle lettere che contengono i dati necessari allo svolgimento dell'istruzione stessa
- recupera i dati dalla buca delle lettere corrispondente al numero trovato nel passaggio precedente e li immagazzina nell'accumulatore
- esegue l'istruzione
- immagazzina i nuovi dati nella buca delle lettere da cui aveva ottenuto i vecchi dati
- ripete il ciclo o si ferma
Comandi[modifica | modifica wikitesto]
Anche se l'LMC in realtà rappresenta il lavoro di un processore binario, è stato scelto di utilizzare numeri decimali per semplicità e per venire incontro agli studenti che potrebbero non essere accostumati a lavorare con il sistema binario o esadecimale.
Istruzioni[modifica | modifica wikitesto]
Alcuni simulatori di LMC sono programmati direttamente con istruzioni numeriche a tre cifre, altri con codici o etichette mnemoniche (sempre di 3 caratteri). In entrambi i casi, il numero di istruzioni è comunque molto limitato (circa dieci istruzioni) per semplificarne la comprensione. Se l'LMC è del tipo che utilizza etichette mnemoniche, queste sono convertite in codici a tre cifre durante la compilazione del programma. La prima cifra di un'istruzione numerica rappresenta il comando da eseguire, e le ultime due cifre l'indirizzo di memoria della buca delle lettere legata a quel comando
La tabella sottostante mostra un insieme di istruzioni numeriche tipico e le relative etichette mnemoniche.
| Codice numerico | Codice mnemonico | Istruzione | Descrizione |
|---|---|---|---|
| 1xx | ADD | ADD | Somma il valore immagazzinato nella casella xx a quello contenuto nell'accumulatore. Il risultato è memorizzato nell'accumulatore.
|
| 2xx | SUB | SUBTRACT | Sottrai il valore immagazzinato nella casella xx da quello contenuto nell'accumulatore. Il risultato è memorizzato nell'accumulatore.
|
| 3xx | STA | STORE | Immagazzina il contenuto dell'accumulatore nella casella xx, cancellandone il contenuto precedente.
|
| 5xx | LDA | LOAD | Carica il valore contenuto nella casella xx nell'accumulatore, cancellandone il contenuto precedente.
|
| 6xx | BRA | BRANCH (incondizionale) | Imposta il Program Counter all'indirizzo xx. Quindi, l'istruzione contenuta nella casella xx sarà la prossima a essere eseguita. |
| 7xx | BRZ | BRANCH IF ZERO (condizionale) | Se l'accumulatore contiene il valore 000, imposta il Program Counter al valore xx, altrimenti, non fare nulla.
|
| 8xx | BRP | BRANCH IF POSITIVE (condizionale) | Se il flag di negatività non è impostato, modifica il Program Counter al valore xx, altrimenti non fare nulla.
|
| 901 | INP | INPUT | Acquisisci dalla casella INBOX il valore digitato dall'utente e memorizzalo nell'accumulatore.
|
| 902 | OUT | OUTPUT | Emetti nella casella OUTBOX il valore presente nell'accumulatore.
|
| 000 | HLT/COB | HALT/COFFEE BREAK | Termina il programma. |
| DAT | DATA | Questa istruzione assembly carica il valore nella prima casella disponibile. DAT si usa anche in combinazione con delle etichette per dichiarare delle variabili. Per esempio, DAT 984 immagazzina il valore 984 nella casella di destinazione dell'istruzione di DAT. |
Esempi[modifica | modifica wikitesto]
Uso dei codici di istruzione numerici[modifica | modifica wikitesto]
Questo semplice programma (dall'istruzione 901 all'istruzione 000) è stato scritto usando solo codici numerici. Il programma accetta due numeri come input e produce la loro differenza come output. L'esecuzione comincia alla casella 00 e finisce alla casella 07. Successivamente verranno discussi gli svantaggi di usare istruzioni a codice numerico per programmare l'LMC.
| Casella | Codice numerico | Operazione | Commenti |
|---|---|---|---|
| 00 | 901 | INBOX --> ACCUMULATOR | INPUT del primo numero, che viene scritto sull'accumulatore (cancellando qualunque cosa vi fosse memorizzata prima) |
| 01 | 308 | ACCUMULATOR --> MEMORY[08] | STORE (Immagazzina nella casella 08) il valore corrente dell'accumulatore, in preparazione al passaggio successivo. |
| 02 | 901 | INBOX --> ACCUMULATOR | INPUT del secondo numero, che viene scritto sull'accumulatore (cancellando qualunque cosa vi fosse memorizzata prima, in questo caso il primo input) |
| 03 | 309 | ACCUMULATOR --> MEMORY[09] | STORE (Immagazzina nella casella 09) il valore corrente dell'accumulatore, sempre in preparazione al passaggio successivo. |
| 04 | 508 | MEMORY[08] --> ACCUMULATOR | Ora che entrambi i numeri in INPUT sono immagazzinati nelle caselle 08 e 09... LOAD (carica) il primo valore di nuovo nell'accumulatore (sempre cancellandone il contenuto) |
| 05 | 209 | ACCUMULATOR = ACCUMULATOR - MEMORY[09] | SUBTRACT (sottrae) il secondo numero al contenuto dell'accumulatore, che contiene il primo numero |
| 06 | 902 | ACCUMULATOR --> OUTBOX | OUTPUT (produce) il risultato del calcolo immagazzinato nell'accumulatore sull'OUTBOX |
| 07 | 000 | (nessuna operazione eseguita) | HALT (ferma) il Little Man Computer |
Uso di istruzioni con etichette e codici mnemonici[modifica | modifica wikitesto]
L'Assembly è un linguaggio di programmazione a basso livello che usa codici mnemonici ed etichette al posto di codici numerici. Nonostante l'LMC faccia ne faccia un uso limitato, si nota subito la convenienza di utilizzare tali codici dall'esempio sottostante, che è il programma appena presentato (sottrazione di due numeri) riscritto in linguaggio assembly: non è più necessario che il programmatore memorizzi un insieme di codici numerici anonimi, ma può programmare usando dei codici mnemonici più facili da ricordare. Se tali codici rappresentano istruzioni che coinvolgono indirizzi di memoria (ad esempio istruzioni di salto o di caricamento e salvataggio dei dati), un'etichetta viene impiegata per identificare l'indirizzo di memoria.
- Questo programma d'esempio può essere compilato ed eseguito sul simulatore di LMC[5], disponibile sul sito internet della York University (Toronto, Canada) o sull'applicazione desktop scritta da Mike Coley.[6] Questi simulatori includono istruzioni complete e programmi d'esempio, il compilatore assembler per convertire il codice assembly in codice macchina, interfacce di controllo per eseguire e osservare i programmi e descrizioni passo passo dettagliate di ogni istruzione dell'LMC.
INP STA FIRST INP STA SECOND LDA FIRST SUB SECOND OUT HLT FIRST DAT SECOND DAT
Etichette[modifica | modifica wikitesto]
Senza le etichette il programmatore dovrebbe calcolare manualmente gli indirizzi di memoria: nell'esempio fatto usando i codici numerici, se una nuova istruzione venisse inserita prima dell'ultima istruzione (HLT), l'istruzione di HLT, attualmente situata all'indirizzo 07, verrebbe spostata all'indirizzo 08 (gli indirizzi vengono etichettati a partire dallo 00). Supponendo che l'utente inserisca 600 come primo input, l'istruzione 308 farebbe sì che questo valore venisse immagazzinato alla casella di indirizzo 08 e sovrascriverebbe l'istruzione 000 (l'HLT). Dal momento che l'istruzione 600 significa "salta alla casella di indirizzo 00", il programma, anziché fermarsi, finirebbe in un ciclo infinito, ricominciando dall'istruzione iniziale (alla casella 00) e tornandoci sempre alla fine (grazie all'istruzione 600, erroneamente memorizzata al posto dell'HLT). Per sopperire a questa eventualità, molti linguaggi assembly (compreso il modello LMC) combinano i codici mnemonici con delle etichette. Un'etichetta è semplicemente una parola usata sia per identificare un indirizzo di memoria dove è immagazzinata un'istruzione o dei dati, sia per riferirsi a tale indirizzo all'interno di un'istruzione.
Quando il programma è compilato dall'assembler:
- Le etichette a sinistra di un'istruzione mnemonica sono convertite nell'indirizzo di memoria in cui l'istruzione o i dati sono immagazzinati, per esempio loopstart INP
- Le etichette a destra di un'istruzione mnemonica prendono il valore dell'indirizzo di memoria indicato sopra, per esempio BRA loopstart
- Un'etichetta combinata con una dichiarazione DAT funziona da variabile e indica l'indirizzo di memoria in cui i dati sono immagazzinati per esempio uno DAT 1 o numero1 DAT 1
Nell'esempio in assembly che usa codici mnemonici ed etichette, se una nuova istruzione venisse inserita prima dell'istruzione finale di HLT allora l'indirizzo di memoria etichettata FIRST diventerebbe 09 anziché 08 e l'istruzione STA FIRST verrebbe convertita in 309 (STA 09) anziché in 308 (STA 08) quando il programma verrebbe compilato.
Quindi le etichette vengono usate per:
- identificare un'istruzione particolare, bersaglio di un'istruzione di salto(BRANCH).
- identificare un indirizzo di memoria utilizzando una variabile (per mezzo dell'istruzione DAT) e nel caso caricare i dati nel programma nel momento di compilazione (questo uso potrebbe non apparire scontato se non si considera che ad esempio non c'è modo di sommare 1 all'accumulatore, a parte chiedere all'utente di inserire il valore 1 all'inizio del programma, ma è chiaramente molto meglio avere già l'1 presente in memoria, usando one DAT 1)
Esempio[modifica | modifica wikitesto]
Questo programma riceve un numero in input dall'utente e lo decrementa di uno fino ad arrivare a zero.
INP LOOP SUB ONE // Etichetta l'indirizzo di memoria con LOOP, l'istruzione poi sottrarrà il valore immagazzinato all'indirizzo etichettato ONE dall'accumulatore OUT BRZ QUIT // Se il valore nell'accumulatore è 0, salta all'indirizzo etichettato QUIT BRA LOOP // Se il valore nell'accumulatore è diverso da 0, salta all'indirizzo etichettato LOOP QUIT HLT // Etichetta questo indirizzo di memoria con QUIT ONE DAT 1 // Immagazzina il valore 1 in questo indirizzo, e lo etichetta come ONE (dichiarazione di una variabile)
Questo programma riceve un numero in input dall'utente, lo eleva al quadrato e lo emette come output, poi ripete richiedendo un nuovo numero. Inserire 0 farebbe terminare il programma.
(Nota: un input che producesse in output un valore superiore a 999 causerebbe un errore nel programma a causa del limite di cifre consentito dal modello LMC).
START LDA ZERO // Inizializza per riproduzioni multiple del programma STA RESULT STA COUNT INP // Input dell'utente BRZ END // Salta all'etichetta END se l'input = 0 STA VALUE // Immagazzina input in VALUE LOOP LDA RESULT // Carica RESULT ADD VALUE // Somma VALUE, ovvero l'input dell'utente, a RESULT STA RESULT // Immagazzina il nuovo RESULT LDA COUNT // Carica COUNT ADD ONE // Somma ONE a COUNT STA COUNT // Immagazzina il nuovo COUNT SUB VALUE // Sottrae l'input dell'utente, VALUE, da COUNT BRZ ENDLOOP // Se è zero (VALUE è stato aggiunto a RESULT un numero VALUE di volte), salta a ENDLOOP BRA LOOP // Salta a LOOP per continuare ad aggiungere VALUE a RESULT ENDLOOP LDA RESULT // Carica RESULT OUT // Produce in output RESULT BRA START // Salta a START per l'inizializzazione e per ricevere un nuovo input VALUE END HLT // HALT - zero è stato immesso come input, quindi esco RESULT DAT // Calcola il risultato (0 di default) COUNT DAT // Contatore (0 di default) ONE DAT 1 // Costante, di valore 1 VALUE DAT // Input dell'utente, ovvero il valore da elevare al quadrato (0 di default) ZERO DAT // Costante, di valore 0 (0 di default)
Nota: Se nessun valore è specificato dopo un'istruzione DAT, di default viene immagazzinato 0.
Note[modifica | modifica wikitesto]
- ^ Little Man Computer, su acs.ilstu.edu, Illinois State University, 1º maggio 2000. URL consultato l'8 marzo 2009 (archiviato dall'url originale il 27 febbraio 2009).
- ^ Yurcik, W.; Osborne, H. (2001). "A crowd of Little Man Computers: Visual computer simulator teaching tools". Proceeding of the 2001 Winter Simulation Conference (Cat. No.01CH37304) 2. p. 1632. doi:10.1109/WSC.2001.977496. ISBN 0-7803-7307-3.
- ^ Yurcik, W.; Brumbaugh, L. (2001). "A web-based little man computer simulator". Proceedings of the thirty-second SIGCSE technical symposium on Computer Science Education - SIGCSE '01. p. 204. doi:10.1145/364447.364585. ISBN 1581133294.
- ^ Osborne, H.; Yurcik, W. (2002). "The educational range of visual simulations of the Little Man Computer architecture paradigm". 32nd Annual Frontiers in Education. pp. S4G–S19. doi:10.1109/FIE.2002.1158742. ISBN 0-7803-7444-4.
- ^ Stephen Y. Chen, Cudmore William C, The Little Man Computer, su yorku.ca, York University. URL consultato il 7 ottobre 2010.
- ^ Mike Coley, The Little Man Computer, su gcsecomputing.org.uk. URL consultato il 12 aprile 2012 (archiviato dall'url originale il 9 dicembre 2016).
Collegamenti esterni[modifica | modifica wikitesto]
- Richard J. Povinelli: Teaching: Introduction to Computer Hardware and Software: Little Man Computer, su povinelli.org.
- The "Little Man" Computer, su elearning.algonquincollege.com. URL consultato il 2 maggio 2019 (archiviato dall'url originale il 5 dicembre 2018).
