In questa parte vedremo con svolge l’esecuzione il calcolatore. Dopo l’introduzione delle micro-istruzioni, l’esecuzione non è più stata legata solo alle variabili di controllo, ma anche da una terza che rappresenta il tempo di clock. Infatti l’esecuzione temporale del programma (per capirci, l’iterfaccia utente) è completamente scollegata da quella interna.
Il pdp8 è legato fondamentalmente da un clock a 4 tempi e questo condizionerà tutto il codice che si vedrà in questa parte. Non è una scelta personale, infatti il pdp8 eseguiva una microi-istruzione (alcune possono essere eseguite in “contemporane”, quindi possono esserci più micro-istruzioni per clock) per ciclo temporale (clock) e quindi il “tempo” deve scandire le varie parti che vengono man mano eseguite. Per comodità, non riporterò per filo e per segno quello che accade con ogni istruzione, ma mi concentrerò sull’analisi della parte più importante e dell’organizzazione.
C’è da puntualizzare che il tempo di chiamata (cioè con quanta frequenza vengono richiamate le funzioni di esecuzione) è dato sempre dalla GUI, quindi il “clock” interno del programma è solamente una semplice variabile per determinare certe condizioni (interne) e non corrisponde ad un intervallo temporale determinato (come invece era per il pdp8 vero e proprio).
self.microistruzioni +="OPR <- MBR(OP) , I <- MBR(I) \n"
414
415
elifself.tempo is3:
416
417
ifself.I =='1'andself.OPR !='111':
418
419
self.R =True
420
421
self.microistruzioni +="R <- 1 \n"
422
423
else:
424
425
self.F =True
426
427
self.microistruzioni +="F <- 1 \n"
– def step() :
Questa funzione determina tutta l’esecuzione del programma. Step incrementa la variabile “tempo” che rappresenta il clock interno del processore e richiama i vari cicli in base alle variabili di controllo F ed R. Si occuperò anche di bloccare l’esecuzione se presente un break e di uscire dall’esecuzione si si presentano degli errori. In questo caso si esce per qualsiasi errore che si presenta, ma in precedenza questo except veniva utilizzato per debuggare il programma e controllare la sua esecuzione.
Come potete immaginare, questa sarà la funzione che verrà richiamata dalla gui per eseguire l’emulazione. Questo ci permette di spostare l’attenzione al solo file pdp8 in caso di malfunzionamenti e di escludere eventuali problematiche derivate dall’interfaccia, visto che l’esecuzione è completamente staccata da quest’ultima.
Le altre funzioni (fetch, indind (indirizzamento indiretto), execute, interrupt) non dovrebbero richiedere particolari spiegazioni, la loro struttura è lineare e rispechia tutte le operazioni che effettuerebbe il calcolatore. L’unica cosa in più è che devono aggiornare le microistruzioni (una stringa) per stampare a video le operazioni eseguite.
Anche se non sono presenti le altre istruzioni, potete dedurre facilmente che queste saranno legate alla variabile tempo (come in fetch per esempio, oppure l’istruzione INP). Le uniche operazioni che possiamo calcolare esternamente con la GUI (e che vedremo nei prossimi articoli), sono i vari tipi di step disponibili. Uno step equivale all’esecuzione completa di un’istruzione, quindi di una riga di codice; un mini step comprende solo un ciclo dei quattro presenti, mentre un micro-step esegue solo una microi-istruzione (corrisponde ad un clock, quindi al variare di una singola unità di tempo). Queste operazioni sono facilmente controllabili dall’esterno, visto che toccano solamente la variabile temporale.
Prima di concludere vorrei fare presente che il ciclo di interrupt non è proprio veritiero, quindi non prendete per buono quello che accade a livello di micro-istruzioni, visto che non simulo nè le periferiche nè l’iterfaccia di collegamento (anche se per il pdp8 sarebbe proprio il processore che si occupa di colloquiare con le periferiche esterne). Le altre istruzioni che trovate nei file sorgente invece sono effettivamente quelle che eseguiva l’originale calcolatore (per quanto riguarda le micro-istruzioni per clock), naturalmente adattate con costrutti python tenendo sempre presente di gestire delle stringhe.
Conclusioni
Credo che questa parte sia molto semplice da comprendere, visto che non ci possono essere molte varianti, ma si deve solamente cercare di simulare l’esecuzione vera e propria del calcolatore. Mi dovete scusare se non ho speso molte parole per analizzare il codice, ma non ci sono scelte particolari od operazioni complesse che si eseguono e quindi preferisco ricevere qualche commento su parti magari più oscure per spiegarle (sempre che ce ne siano) che descrivere ancora più minuziosamente operazioni semplici come quelle che avete letto.
Nel prossimo articolo cominceremo a vedere l’interfaccia grafica, così da poter capire meglio come quest’ultima interagisce con il programma vero e proprio. Spero che sia utile vedere il funzionamento di tkinter, perché oltre ad essere integrata in python, rispecchia logicamente il funzionamento delle librerie più ricche come GTK e QT.
In Appunti Digitali cerchiamo di esprimere punti di vista informati su questioni che conosciamo, materie che pratichiamo professionalmente o passioni seguite a lungo e con metodo. Nei limiti del poco tempo che possiamo dedicare alla scrittura di articoli, speriamo di aiutarvi a costruirvi un’opinione su materie complesse, informarvi e se possibile divertirvi. I conti del server li paghiamo di tasca nostra e ci riserviamo perciò di moderare i commenti a nostra discrezione.
