Simulator procesor DLX - Despre procesor.
Pagina introductiva
Despre program - folosire
Despre resursele procesorului
Despre procesor - operatii
Despre intreruperi
Specificatii de program
Contactati-ne pe web !
Structura procesorului:
Legenda:
- UAL = Unitatea Aritmetico - Logica pentru intregi (pur combinationala)
- RG[32;32] = registrele generale biport
- TS1, TS2, TD = registre tampon pentru registrele generale, transparente pentru programator
- TEMP = registru temporar transparent pentru programator - ATENTIE: TEMP este folosit pentru aducerea de date. Astfel se unifica modurile de adresare - ramane numai adresarea imediata si deci scade complexitatea procesorului. Pe de alta parte, se va pierde un ciclu de ceas.
- RAI = Registrul Adresei de Intrerupere - ATENTIE: In cazul real, intreruperile puteau fi generate de catre echipamente externe, de acces incorect la memorie, de defectarea unor componente, de operatii eronate. In cazul simulat, este clar ca nu se poate defecta memoria si nici echipamente externe nu exista, deci folosirea sistemului de intreruperi este net diminuata, ea reducandu-se la generarea de erori si, eventual de construirea unor mici rutine de tratare care sa fie in prealabil (inainte de pornirea procesorului) incarcate in memoria sa.
- CP = Program Countor
- RA = Registrul de adrese (in el se incarca adresa de la care dorim sa citim din memorie)
- RD = Registrul de date (in el se incarca ce s-a citit din memorie)
- RI = Registrul instructiunii
- M = Memoria interna
Operatiile UAL:
- operatii aritmetice si logice: S1 + S2 ; S1 - S2 ; S1 sau S2 ; S1 si S2 ; S1 sau exclusiv S2
- operatii de deplasare logica: S1 << S2 ; S1 >> S2
- operatii de deplasare aritmetica: S1 >>a S2
- constante: 0 ; 1
Formatele instructiunilor:
1) Instructiuni de tip I (imediat):
Registrul de 32 de biti are urmatoarele campuri:
- COP = codul operatiei = pe 6 biti
- rs = adresa registrului sursa = pe 5 biti
- rd = adresa registrului destinatie = pe 5 biti
- imed = adresa operandului imediat sau chiar valoarea operandului imediat = pe 16 biti
Instructiunile care apartin acestui tip sunt:
- Incarca / Memoreaza octet, semicuvant, cuvant
- RG[rd] <- RG[rs] @ imed , unde @ este un operator aritmetic sau logic
- ramificare conditionata: rs = registru ; rd = nefolosit
- salt la adresa specificata de registru (cu sau fara revenire): rt = 0 ; rs = destinatie ; imed = 0
2) Instructiuni de tip R (registru - registru):
- Registrul de 32 de biti are urmatoarele campuri:
- COP = codul operatiei = pe 6 biti
- rs = adresa registrului sursa = pe 5 biti
- rt = adresa celui de-al doilea registru sursa = pe 5 biti
- rd = adresa registrului destinatie = pe 5 biti
- funct = o extensie a codului de operatie folosita pentru codificarea mai multor operatii = pe 11 biti
Instructiunile care apartin acestui tip sunt:
- campul func codifica instructiunile operationale aritmetice si logice, instructiunile de scriere / citire in / din registrul special RAI si instructiunile de deplasare: RG[rd] <- RG[rs] (func) RG[rt]
3) Instructiuni de tip J (jump):
- Registrul de 32 de biti are urmatoarele campuri:
- COP = codul operatiei = pe 6 biti
- imed / offset = folosit pentru generarea adresei de salt = pe 26 biti
Instructiunile care apartin acestui tip sunt:
- RET = salt simplu cu legatura
- TRAP = intrerupere
4) Instructiuni de ramificare si salt.
5) Instructiuni pentru virgula mobila.
Modurile de adresare prevazuta in istructiuni:
1) Imediat. Operandul se afla in instructiune:
2) Registru. Operandul se afla intr-un registru specificat de campul rs:
3) Cu deplasare bazata. Continutul unui registru se aduna cu campul imediat pentru a forma adresa:
4) Relativa la CP, cu offset de 16 biti (extensia semnului):
5) Relativa la CP, cu offset de 26 de biti (extensia semnului):
Instructiunile implementate efectiv in simulator:
1) De incarcare in registre: Din considerente prezentate in pagina Despre program - realizare, este necesar sa existe o instructiune care incarca o valoare specificata intr-un registru specificat: LOAD Ri,j; //adica incarca valoarea zecimala j in registrul general Ri. (Load)
2) De incarcare din memorie in registre:
LW Ri,j(Rk); //R[i] <- M[j+R[k]] (Load Word)
LB Ri,j(Rk); //R[i] <- 32{(M[j+R[k]]0)24 ## M[j+R[k]]24..31} (Load Byte)
LBU Ri,j(Rk); //R[i] <- 32{(0)24 ## M[j+R[k]]24..31} (Load Byte Unsigned)
LH Ri,j(Rk); //R[i] <- 32{(0)16 ## M[j+R[k]]16..31} (Load High)
3) De descarcare din registre in memorie:
SW j(Rk),Ri; //M[j+R[k]] <- R[i] (Store Word)
SH j(Rk),Ri; //M[j+R[k]] <- 32{(0)16 ## R[i]16..31} (Store High)
SB j(Rk),Ri; //M[j+R[k]] <- 32{(0)24 ## R[i]24..31} (Store Byte)
4) Aritmetice si logice:
ADD Ri,Rj,Rk; //R[i] <- R[j] + R[k] (Add)
ADDI Ri,Rj,#n; //R[i] <- R[j] + n (Add with Immediate)
LHI Ri,#n; //R[i] <- temp unde temp <- 32{(n)} si apoi temp16..31 <- (0) (Load High Immediate)
SLLI Ri,Rj,#n; //R[i] <- R[j] <<n (Shift Logic Left Immediate)
SLT Ri,Rj,Rk; //if(R[j] < R[k]) then R[i] <- 1 else R[i] <- 0 (Set Less Than)
5) De ramificare si salt:
J n; //salt la linia n din program (Jump)
J Ri; //salt la linia data de valoarea continuta de R[i] (Jump Register)
JAL n; //salt la linia n din program cu salvarea PC in R[31] (Jump And Load)
JALR Ri; //salt la linia data de valoarea continuta de R[i] cu salvarea PC in R[31] (Jump And Load Register)
BEQZ Ri,n; //ramificare daca R[i]==0 la linia n (Brench if EQual Zero)
BNEZ Ri,n; //ramificare daca R[i]!=0 la linia n (Brench if Not Equal Zero)
Pentru a rula pagina la inceput (la meniu) dati un click aici.