= L'assembleur =
Style mips, c'est le plus simple : plein de registres + un registre zero qui contient toujours 0
2 types d'instructions
- [alu rdest r1 r2] pour les operations arith/logiques où alu parcours {add, sub, or, and, ... }
prends aussi en compte move car : move $rdest $r ~ or rdest $r $zero
prends aussi en compte les jump avec move $pc $x
- [load dest addr/store orig addr] qui prends ou mets des trucs dans la RAM à l'addresse $addr
De plus, chaque instruction prends un registre supplementaire $c en argument et ne s'execute que si celui ci est nul (sinon elle devient move $zero $zero ~ nop). Cela permet le branching et on met $zero pour faire le mips usuel.
Encodage : chaque instruction sur 4 mots
[op][arg1][arg2][arg3] (quand l'operation a moins d'arguments on pad avec des 0)
où :
op =
| 00[alu_type] => operation sur l'alu { arg1 = rdest, arg2 = r2, arg3 = r3}, on transmet alu_type
| 10(0*) => load { dest = arg1, addr = arg2 }
| 11(0*) => store { orig = arg3, addr = arg2 }
(le 0* c'est qu'on complète par des zeros, on est indépendant de la taille du mot à la compilation)
= La ROM =
Elle va lire les mots 4 par 4 parceque c'est la taille de nos instructions donc c'est plus simple :
- une entrée read_addr[wordsize]
- une sortie instr[4*wordsize]
= La RAM =
- deux entrée read_addr[wordsize], write_addr[wordsize]
- une entrée write_data[wordsize] et une entrée write[1]
- une sortie read_data[wordsize]
si write est à 1 la RAM écrit write_data à l'addresse write_addr etc.
= Architecture =
Un registre spécial $pc est toujours branché sur le read_addr de la ROM. Il s'incrémente de plus tout seul a chaque tick d'horloge.
Tous les sorties registres sont branchés sur 2 gros selecteurs qui prennent en argument arg2 et arg3 resp.
En gros on a 3 mots qui valent a tout moment $arg2 et $arg3 resp.
De même les entrées sont branchées sur un selecteur qui vaut $arg1$.
Donc a chaque instruction, on écrits TOUJOURS le résultat de quelquechose dans $arg1 et on lit TOUJOURS $arg2 et $arg3
r1_read == | |
r2_read == | SELECT (instr[wordsize:2*wordsize]) |
... | | == arg2
rn_read == | |
pareil pour arg3
Pour alu & load:
arg2 =(read_addr)= [RAM]
||
(read_data)
_____ ||
arg2 =(input1)= | ALU | =(output)= select(op[0:2]) == arg3
arg3 =(input2)= |_____|
Pour brifzero :
zero
|
arg2 == is_zero -- select(op[0:2]) -- pc_overwrite
||
pc_write
= Organisation =
- jop/ : Module camlp4 et runtime pour la compilation ml => netlist.
- circuits/ : Fichiers ml décrivant des netlists.
- netlists/ : Netlists générées et fichiers d'input.
- simulator/ : Simulateur de netlist en java. L'utilisation est expliquée en executant JOP_Simulator.jar sans argument (java -jar JOP_Simulator.jar)
= Comment lancer une demo ? =
Les demos dispos sont (pour l'instant) :
./rundemo.sh full_adder
Teste tout les combinaisons d'entrées sur un full adder décrit dans circuits/full_adder.ml
Sortie espérée : 0 1 1 1 2 2 2 3
./rundemo.sh minus
Fais le moins unaire de l'entrée (ici 100000000...)
Sortie espérée : 11111111111....
./rundemo.sh count <n>
Incrémente un compteur modulo 2^n pendant 32 ticks d'horloge.
Sortie espérée :
- 0 1 2 3 ... ((2^n)-1) 0 1 ... (valeur du compteur)
- 0 0 0 0 ... 1 0 0 ... (bit d'overflow)
./rundemo.sh modn <n>
Même chose que pour count, mais on a ici un compteur modulo n, avec n quelconque.
./rundemo.sh clk2
Effectue une division d'horloge.
Sortie attendue : 110011001100...
(ou la même chose avec un déphasage de 1 pour l'autre sortie)
Le code des circuits n'est pour l'instant pas très beau, ceci étant dût à quelques soucis avec camlp4, work in progress.
= Est-il possible de faire ces démos avec nos propres inputs d'entrée ? =
Bien sûr, il suffit pour cela de modifier le fichier d'extension ".nl.input" correspondant.
Les fichiers input sont concus de telle manière :
Tout d'abord le nombre de cycle d'horloge à simuler,
Puis pour chaque input, le nom de la variable suivie (séparés par des espaces) les valeurs au cours du temps.
Un exemple de fichier pourrait être :
8
a 0 1 0 0 0 1 1 1
b 0 0 1 0 1 0 1 1
ci 0 0 0 1 1 1 0 1