Modèle Verilog du processeur

Modélisation Verilog
simple µP (32-bit)
P. Bakowski
[email protected]
Architecture du processeur
Ce modèle implémente un simple processeur 32-bit.
Dans la version initiale le processeur n’a pas de
registres. Il communique directement avec la
mémoire interne.
Dans la version finale il faut ajouter le registre de
travail (accumulateur) et les registres entrée-sortie
pour la communication avec la mémoire externe.
Le processeur doit communiquer avec notre soussystème mémoire externe via le bus de données, bus
d’adresses et les lignes de contrôle (WE,OE).
Le code Verilog du processeur est disponible ici.
P. Bakowski
2
Système complet
address bus
OE
WE
CS0
CS1
CS2
CS3
data bus
P. Bakowski
3
Architecture du processeur
Liste d’instructions
opcode name
NOP HLT BRA STR CPL ADD MUL SHF
... ... comments
no operation ..
halt ..
branch if flag of type CCODEis set, branch to BB store if IMMED, MEM[BB] <= AA else MEM[BB] <= MEM[AA] complement if IMMED, MEM[BB] <= ~AA else MEM[BB] <= ~MEM[AA] add MEM[BB]<=MEM[BB] + MEM[AA] multiply MEM[BB]<=MEM[BB] * MEM[AA] shift
if SHLEFT, shift MEM[BB] left by SHDIST, else shift right
P. Bakowski
4
Architecture du processeur
Formats d’instructions
P. Bakowski
5
Modèle Verilog du processeur
La description comporte un seul module
qui intègre le processeur et la mémoire.
Le module commence par la déclaration de la mémoire.
La taille proposée est 2**12 de 32-bit mots.
Le compteur du programme a 12 bits.
Le mot-clé 'define définie les champs d’instructions et
les opcodes.
Le bloc task setcondcode est un processus qui
compute les valeurs des drapeaux de condition (status
flags).
P. Bakowski
6
Modèle Verilog du processeur
Le processus always execute une instruction du programme
enregistré dans la mémoire : initialement une instruction est lue dans la MEM et le PC est
incrémenté; puis l’instruction est décodée par le mécanisme
de case.
La sélection:
if ('IMMED) MEM['BB]='AA;
else MEM['BB] = MEM['AA];
détermine deux modes d’adressage: immédiat et direct.
P. Bakowski
7
Modèle Verilog du processeur
module system;
parameter
step = 10, // execution time of one instruction
width = 32, // data bus width
addrsize = 12, // address bus width
memsize = 1<<addrsize, // memory size
sbits = 6; // number of status bits
reg[width-1:0] MEM[0:memsize-1], // memory declaration
IR; // instruction register declaration
reg[sbits-1:0] SR; // status register
reg[addrsize-1:0] PC; // program counter
'define OPCODE IR[31:28] // opcode
'define AA IR[23:12] // operand AA
'define BB IR[11:0] // operand BB
'define IM IR[27] // operand type 1: immediate 0: memory
'define CCODE IR[27:24] // branch condition
'define SHL IR[27] // shift direction 1: left 0: right
'define SHD IR[16:12] // shift distance
P. Bakowski
8
Modèle Verilog du processeur
//instruction codes
'define HLT 4'b0000
// halt
'define BRA 4'b0001
// branch
'define NOP 4'b0010
// no-op
'define STR 4'b0011
// store
'define SHF 4'b0100
// shift
'define CPL 4'b0101
// complement
'define ADD 4'b0110
// add
'define MUL 4'b0111
// multiply
//condition code and status bit position
'define ALWAYS
0
'define CARRY
1
'define EVEN
2
'define PARITY
3
'define ZERO
4
'define NEG
5
P. Bakowski
9
Modèle Verilog du processeur
//set flags
task setcondcode;
input [width:0] RES;
begin
SR['ALWAYS]
= 1;
SR['CARRY]
= RES[width];
SR['EVEN]
= ~RES[0];
SR['PARITY]
= ^RES;
SR['ZERO]
= ~(|RES);
SR['NEG]
= RES[width-1];
end;
end task;
//reset: start module
initial
PC = 0;
P. Bakowski
// start program
10
Modèle Verilog du processeur
always begin
// execution time of one instruction
#step
IR = MEM[PC];
//instruction fetch
PC = PC + 1;
//increment program counter
case('OPCODE)
'NOP:;
//nothing to do
'BRA: if (SR['CCODE])
//branch
PC = 'BB;
'STR: if ('IM)
MEM['BB] = 'AA;
//store
//immediate
else
MEM['BB] = MEM['AA];
//direct
'ADD: begin
MEM['BB] = MEM['AA] + MEM['BB];
setcondcode(MEM['BB]);
end
P. Bakowski
11
Modèle Verilog du processeur
'MUL: begin
MEM['BB] = MEM['AA] * MEM['BB]; setcondcode(MEM['BB]);
end
'CPL: begin
if ('IM)
//complement store
MEM['BB] = ~'AA;
//immediate
else
MEM['BB] = ~MEM['AA];
setcondcode(MEM['BB]);
end
'SHF: begin
if ('SHL)
//shift
MEM['BB] = MEM['BB] << 'SHD;
else
MEM['BB] = MEM['BB] >> 'SHD;
//left
setcondcode(MEM['BB]);
end
'HLT: $finish
// halt
default: $display("erreur: mauvaise valeur dans op-code");
endcase;
end
endmodule;
P. Bakowski
12
Phases d’intégration plus rapport
1. Simuler le modèle du processeur avec sa mémoire
interne.
2. Modifier le code du processeur par l’introduction d’un
registre de travail – accumulateur, et les tampons de
communication avec la mémoire externe.
3. Ajouter les bus et les signaux de contrôle.
4. Intégrer l’ensemble avec votre sous-système mémoire.
5. Simuler ensemble avec un court programme dans la
mémoire externe (quelques instructions dans une boucle).
6. Rédiger un court rapport (max.6 pages + listing)
concernant votre mini-projet (base d’évaluation).
P. Bakowski
13