Romanian

From jmips

BD

BG

CN

EN

ES

ET

FR

DE

IN

IT

JP

PL

RO

RU

Procesorul MIPS în Java

Detail architecture of the basic unpipelined MIPS processor

Familiarizarea cu software-ul este recomandată, deoarece aceasta contribuie către învăţarea despre arhitectura hardware-ului MIPS şi te va ajuta să te familiarizezi cu conceptele generale folosite in sistemelor informatice și arhitectura acestora.

Arhiva conține cinci modele de procesoare care pot fi analizate sau testate, identificate în descrierea de mai jos aici cu numere 1 la 5. Odată cu numerele din clasament, complexitatea modelui descris crește de asemnea, după cum urmează:

1. Procesor de bază (unpipelined) (these pages)
2. Procesor neoptimizat cu pipeline
3. Procesor optimizat cu pipeline
4. Procesor optimizat cu pipeline cu cache de memorie
5. Procesor optimizat pipeline cu memorie cache şi manipulare întreruptă

Paginile următoare vă vor ghida în detaliu prin procesele de utilizare şi de construcție a unui procesor de bază, urmând apoi să considerăm și modelele mai sofisticate. Diferențele dintre modele nu au de a face cu modul în care acestea sunt construite sau utilizate. Ele sunt diferite doar la nivelul structurii interne, aceasta determinând ca unele modele, să fie mai rapide decât altele utilizate în aceleași condiții.

Este recomandat să lucrați, pe rând, cu fiecare model de procesor, probabil cu scopul de a îmbunătăţi modelul în cauză, făcându-lsă ruleze mai rapid.

Duratele rulării generale și a fiecărei comenzi reprezintă unul dintre output-urile standard. Dacă doriţi să obţineţi statistici, de exemplu durata, în circumstanţe speciale, a execuției per clasă de instruire, va trebui să adăugaţi dvs. codul. În fond, este open source! Puteţi face acest lucru. Codul este scris clar şi explicat în paginile pe care le găsiți aici.

Cum să rulezi modelul de bază a unui procesor MIPS

În arhiva zip sau în fişierul comprimat tar (furnizate pe proiectului jMIPS ar trebui să găsești o arhivă Java (un jar). Dacă nu există, atunci du-te la secţiunea referitoare la next section. Este de asemenea recomandat să extrageţi fişierul jar de arhiva cu (de exemplu, numele de arhivă, în funcţie de alegerea personală de descărcare).

% unzip jMIPS-1.7.zip jMIPS-1.7/lib/CPU.jar

sau

% tar xzvf jMIPS-1.7.tgz jMIPS-1.7/lib/CPU.jar

De asemenea, extrage și o parte din conținutul fișierului misc, folosind

% unzip jMIPS-1.7.zip jMIPS-1.7/misc/hello_mips32

sau

% tar xzvf jMIPS-1.7.tgz jMIPS-1.7/lib/hello_mips32

apoi clasa Cpu1 va putea fi rulată în orice platformă, cu Java Virtual Machine (JVM). În Linux, încearcă

% java -cp jMIPS-1.7/lib/CPU.jar CPU.Cpu1 -q jMIPS-1.7/misc/hello_mips32

De exemplu:

% java -cp jMIPS-1.7/lib/CPU.jar CPU.Cpu1 -q jMIPS-1.7/misc/hello_mips32
  Hello world
%

Cum să compilezi modelul de bază a unui procesor MIPS

Dacă doriţi sau trebuie să compilaţi codul sursă Java pentru a obţine codul executabil, faceți după cum urmează, în funcţie de instrumentele de care aveţi la dispoziţie. Deoarece există o varietate de instrumente pe care oamenii le folosesc în funcție de sistemul de operare pentru care optează, urmatoarele subsecțiuni sunt specifice unui anume sistem de operare.

Compilarea sub Linux sau Unix

Dacă sunteţi pe un Mac, şi folosiți un HFS sau HFS + format file system, mergeţi la 'System Properties' şi activați opțiunea de case sensitivity. Veţi avea nevoie ca, altfel fişierele vor intra în coliziune unele cu altele.

Dezarhivaţi arhiva zip sau fişierul comprimat tar (furnizate la proiectului jMIPS link de download), cu

% unzip jMIPS-1.7.zip

respectiv

% tar xzvf jMIPS-1.7.tgz

Apoi găsiti fișierul src/ și schimbați-vă fișierul curent la acea locație (folosiți comanda cd jMIPS-1.7/src). Personal, prefer sa produc generic Java bytecode, pentru Java Virtual machine (JVM), cu

% javac CPU/Cpu1.java

în fișierul src/ iar apoi file-ul care rezultă Cpu1.class va putea fi rulat de JVM în orice platform. În Linux, puteți folosi

% java CPU/Cpu1 -q ../misc/hello_mips32

De exemplu:

% java CPU/Cpu1 -q ../misc/hello_mips32
  Hello world
%

Constucția unui fișier jar depinde doar de construcția claselor Java:

% javac CPU/*.java
%

iar apoi faceți un fișier jar cu

% jar cf ../lib/CPU.jar CPU/*.class
%

De fapt, un fișier jar nu este decât o arhiva zip a pachetului, realizată fără comprimare, dar conținând un extra fișier de manifest. Așadar, puțeți să îl construiți folosindu-vă doar de un zip achiever, fără să fie neapărată nevoie de o unealtă jar. Pentru detalii, consultați Java, sau examinați un jar existent, folosing un achiever-ul zip fără comprimare.

Compilarea sub Windows

Pentru a importa într-un Java NetBeans IDE, creați un nou proiect NB (denumit `jMIPS", poate), asigurându-vă ca toate căsuțele din dialog box-ul IDE, `Main Class', etc, sunt toate ne-tickuite.

Odată ce IDE-a construit toate directoarele şi fişierele de control de care are nevoie, copiaţi fişiere *.java din directorul src / CPU / într-un nou subdirector src/CPU/al directorului proiectului jMIPS creat de NetBeans. De la sursa de arhiva cod la un nou src / CPU / subdirector din directorul de proiect jMIPS care tocmai a fost creat de NetBeans.

Dacă este posibil, utilizaţi o comandă de copiere direct din interiorul arhivei zip, pentru a evita ca fişierele atingă discul de pe drum. În cazul în care Netbeans are o comandă în meniu care vă permite să importați de la zip, sau de compilare de la o arhivă zip, aceasta ar fi perfect.

IDE-ul va detecta faptul ca dvs. populați zona de cod sursă şi va extinde `Pachetul sursa" într-o structură de tip arbore (directorul jMIPS / src) pentru a include "pachet" CPU şi fişierele Java ale acestuia.

Alternativ, puteţi redenumi sistematic fişierele din clasa Java, pentru fiecare model de procesor de la Cpu1.java, Cpu2.java, etc, la, de exemplu, WinCpu1.java, WinCpu2.java, etc. Va trebui să redenumiţi clasa a declarată în cadrul fiecărui fişier pentru a se potrivi.

Note pentru rularea unui model de procesor

Opţiunile în linia de comandă sunt după cum urmează:

• No options: rularea modelului fără opțiuni, (în particular fără -q; adică fără "quiet") va lista fiecare instrucțiune din machine code, pe masură ce aceasta este executată, cu informații referitoare la timpul de execuție atașate.

% java CPU.Cpu1  hello_mips32
0:      0.000000007s:   0x80030080:     addiu $29, $29, -32
1:      0.000000012s:   0x80030084:     sw $31, 28($29)
2:      0.000000019s:   0x80030088:     sw $30, 24($29)
3:      0.000000024s:   0x8003008c:     addu $30, $29, $0
4:      0.000000030s:   0x80030090:     sw $28, 16($29)
...
218:    0.000001567s:   0x8003000c:     lui $3, -20480
219:    0.000001573s:   0x80030010:     ori $3, $3, 16
220:    0.000001580s:   0x80030014:     sb $3, 0($3)
%

Au fost executate 220 instrucțiuni în 0.000001580 secunde simulate (rata ceasului este de 1 GHz simulat). Asta înseamnă aproximativ 5 bătăi de ceas per execuție de instrucțiune.

• -q: -q (quiet - "liniste"), suprima lista de instrucţiuni mchine code-ului desasamblat pe măsură ce aceastea rulează. Cu alte cuvinte, cu-q poți vedea doar ceea ce programul executat trebuie să producă, şi nici un fel de alt noise suplimentar.

% java CPU.Cpu1 -q hello_mips32
Hello world
%

• -d: mai multe informații sunt oferite dacă -d ("debug") este dat. Repetarea opțiunii -d crește noise-ul din debugging.

% java CPU.Cpu1 -d hello_mips32
text start at virtual addr 0x80030000 file offset 0x10000
text end   at virtual addr 0x800300e0 file offset 0x100e0
text entry at virtual addr 0x80030080 file offset 0x10080
read 224B at offset 65536 from file 'hello_mips32'
stack start at virtual addr 0xb0000000
stack end   at virtual addr 0xb0100000
0:      0.000000007s:   0x80030080:     addiu $29, $29, -32
1:      0.000000012s:   0x80030084:     sw $31, 28($29)
2:      0.000000019s:   0x80030088:     sw $30, 24($29)
...
%

• -o: Puteţi seta anumite variabile interne în simulare prin -o MEMORY_LATENCY = 1000 (de exemplu). Căutați codul în Cmdline.java şi adaugați propriile setări posibile la lista care momentan este una foarte scurtă!

Vă invităm sa editaţi sursa, în scopul de a adauga orice altceva doriţi; adăugaţi-vă la lista de credite din partea de sus a codului sursă şi trimiteți înapoi codul modificat - sau publicați-l în altă parte, după cum doriţi.

Producerea codului maşină MIPS pentru a fi rulat in procesor

Programul gata-construit in cod-maşina MIPS R3000 "Hello world" este salvat în arhivă cu titlul hello_mips32 in subdirectorul misc/

Codul sursă (în limbajul C) pentru "Hello world" se află in fişierul hello_mips32.c în directorul arhivă misc/' şi asamblorul MIPS al acestui program este hello_mips32.s. Maşina cod a fost compliata într-o manieră standard de la sursa data pentru a îi oferi cod maşinii, prin intermediul

% gcc -static -o hello_mips32 -Wl,-e,f hello_mips32.c

o maşină MIPS reală. Vă rugăm să verificaţi manualul pentru comanda gcc ("man gcc") pentru a afla exact ce înseamnă opţiunile din această linie de comandă.

În platformele de tip Unix şi nu non-MIPS, următoarele comenzi au acelaşi rezultat ca cel de mai sus folosind cross-compilatorul mips-gcc(în majoritatea cazurilor va trebui să rulaţi comanda "setup MIPS" în shell environment pentru a seta calea de executare să selecteze parţile componente ale cross-compilatorului)

% mips-gcc -DMIPS -mips1 -mabi=32 -c hello_mips32.c
% mips-ld -Ttext 0x80003000 -e f -o hello_mips32 hello_mips32.o

Modelul software al unui procesor MIPS este folositor pentru o maşină MIPS reală cand utilizatorul rulează cod-maşina "Hello World".

% java CPU/Cpu1 -q hello_mips32
Hello world

Totuşi, un cod maşină mai complicat care foloseşte întreruperi si peripherals are putea depăşi acest model.

Codul sursă

Acestea sunt câteva sugestii pentru a pătrunde in codul sursă.

• Selectaţi o parte din codul sursă al clasei Java CPU1 şi comentaţi-l aşa cum doriţi. Deşi codul este însoţit de comentarii cuprinzătoare, cu siguranţă veţi găsi părţi care ar putea fi îmbunătăţite(sau comentate diferit).

În acest caz, editaţi-l, semnaţi-l şi trimiteţi modificările proiectului.

Aceasta este o metodă foarte buna pentru a vă îmbunătăţi inţelegerea codului: în prima instanţă realizaţi dacă este prost comentat şi dificil de înţeles şi apoi îmbunatăţi-ţi-l.

Veţi găsi comentarii cuprinzătoare referitoare la cod în secţiunile următoare. Este recomandat să citiţi codul ţinând cont de comentarii. Comentariile vor fi extrem de folositoare pentru înţelegerea la scară mare a atributelor proiectului, lăsând doar nuanţele să fie explicate prin comentarii ale codului sursă.

• Adăugaţi instrucţiunile bgezal şi bltzal la setul de instrucţiuni MIPS gestionate în singurul loop din emulator.

În prima instanţă, verificaţi ce fac instrucţiunile şi care este formatul pentru cod! După nume se poate spune ca ar trebui să fie o intersecţie între o ramură de instrucţiuni şi o instrucţiune jump-and-link. Puteţi presupune că bgezal este asemănătoare cu bgez dar în cazul în care testul este valid face acelaşi lucru ca o instrucţiune jal (plasează adresa următoarei instrucţiuni în registrul adresei de returnare, ra). Acest lucru este folositor pentru implementarea unui apel condiţional de subrutină. Verifică Google!

Editaţi codul pentru HEllo world cu un editor binar("bvi" este potrivit pentru Unix sau dacă sunteţi un utiliyator vi; utilizatorii emacs vor ştii deja că emacs are o opţiune de utilizare cu editor binar) şi inlocuiţi bnez v0, foo cu codul pentru bgezal v0, foo.

Testaţi emulatorul modificat pe codul de maşină schimbat. Va trebui să compensaţi cu o schimbare a programului pentru a salva şi restabili registrul adresei de returnare in jurul ramurei, dar veţi vedea că noua instrucţiune din ramură funcţionează.

Notă asupra modelului codului de bază al procesorului MIPS

Regularitatea arhitecturii setului de instrucţiuni MIPS rezultă într-un cod al simulatorului transparent. Codul simulatorului a fost deasemenea scris cu obiectivul de a produce cod care este clar fara a fi foarte sofisticat.

Ca rezultat, puteţi verifica ce face orice instrucţiune MIPS prin scanarea codului corespunzător.

Codul clasei CPU1 este imperativ doar cu minimum de amabalare orientată pe obiect pentru a îl face uşor de parcurs. Este vorba despre o state machine! Şi aşa este şi în realitate. Tot ce trebuie sa citiţi pentru a înţelege modelul procesorului CPU1 se afla in codul clasei CPU1 şi nicîieri altundeva.

Veţi observa că există doar un loop în cod. Acesta rulează ciclul generic Von Neumann fetch-decode-(read data)-execute-(write data), aşa cum este implementat în toate procesoarele de masă începând cu 1940, şi toată acţiunea este cuprinsă în acest loop cuprinzător, cu o scurtă parte dedicată fiecărui tip de instrucţiune MIPS. Deci veţi găsi aproximativ 10 sau 12 scurte secţiuni contigue care alcatuiesc corpul loopului.

De exemplu, partea care se ocupă de instrucţiunile jump arată după cum urmează('fetch' a fost deja executată la inceputul loopului, pentru a citi urmatoarea intrucţiune în registrul IR).

    /*
     *  Jump instructions
     *
     *  format  J  : 000010 jjjjj jjjjj jjjjjjjjjjjjjjjj 
     *          JAL: 000011 jjjjj jjjjj jjjjjjjjjjjjjjjj
     *
     *  action  of J, JAL:
     *  PC <- (bigpageof(PC) << 28) | (jjj...jjj << 2);
     *
     *  extra action of JAL:
     *  RA <- PC
     */
  if (op == J || op == JAL) {
      conf.jjjjjjjjjjjjjjjjjjjjjjjjjj = IR.jDST();              // decode:  IR register
      pc = PC.read();                                           // read:    PC register
                                                                // execute: (not present)
      if (op == JAL)                                            // write:   RA and PC register
          register_unit.write (R_RA, pc);
      PC.write((bigpageof(pc) << 28) | (conf.jjjjjjjjjjjjjjjjjjjjjjjjjj << 2));
  }

Acestea constituie doar 6 rânduri de cod real, fară a număra rândurile de comentarii.

Modelul codificat de clasa CPU1 cuprinde un design de procesor Von Neumann abstract fără a cuprinde detalii despre cum electronii sunt amestecaţi şi nu ar trebui să aveţi nici o problema în a citi codul şi înţelege ce face ca hardware. (sfat: când studiaţi orice secţiune mică a codului, asiguraţi-vă că o faceţi cu un anumit scop, ca de exemplu cum este folosita funcţia x pentru ca apoi să o puteţi folosi pe cont propriu şi ignoraţi orice alt detaliu până cand înţelegeţi procesul)

Diferenţa privitoare la hardwarele reale este ca acest cod poate face doar un singur lucru, în timp ce fizica rezultă în hardware-ul făcând mai multe lucruri simultan de-a lungul unui ciclu al procesorului.

Totuşi, execuţia este timed folosind metodele din clasa Clock şi calculele finale referitoare la ce s-a petrecut vor fi finalizate când s-a încheiat un ciclu complet al procesorului. Aşadar, ordinea efectuării în software nu este neapărat importantă. Atâta timp cat ordinea are logică, modelul funcţionează.

De exemplu, codul jump de mai sus scrie in registrul RA datele citite din instrucţiunea din registrul IR. Atunci cand este vorba despre registrul hardware, aceste doua lucruri se intamplă simultan, ca rezultat al unui câmp electric potenţial transmis printr-un fir conductiv. În codul de mai sus, citirea are loc înainte de scriere, deoarece implementarea in Java cere acest lucru. Java nu permite citirea si scrierea simultană. În schimb, fizica universului real face ca acest lucru să fie posibil. Totuşi, componentele implicate vor inregistra acelaşi moment al întamplării pentru citire şi scriere şi aceasta este ceea ce utilizatorul va putea vedea la sfârşit.

Aspectul clasei

În codul sursă există următoarele clase de nivel superior. Doar primele cinci conţin cod care merită menţionat. Discuţia va continua după sfârşitul urmatorului tabel:

Acesta este aşa numitul desgin domain-model. Clasele din acest cod software corespund componentelor fizice reale din procesorul hardware MIPS. Metodele corespund operaţiunilor fizice reale pe care componentele hardware le pot efectua. Operaţiunile virtuale, precum acelea care pot fi compuse din combinaţii de operaţii mai simple, nu sunt niciodata implementate in software indiferent cât de convenabil ar parea, deoarece nu există fizic.

UML class diagram for jMIPS code

Diagrama clasei din drepate arată dependenţele.

Dacă doriţi să adăugaţi o faciliate cu un singur pas simulatorului Cpu1, trebuie sa modificaţi while loopul fetch-decode-execute din codul Cpu1 şi să îl faceţi să se oprească în aşteptarea user inputului înainte de un ciclu nou. Este recomandat sa creaţi un s ("step") de la ustilizator pentru a executa un noi ciclu; un c ("continue") ar trebui sa execute ciclul la infinit; un p ("print") impreună cu un număr de registru sau o adresă de memorie ar trebuie să arate ce conţine registrul sau memoria; a d ("display") ar trebui sa fie precum printarea, dar să printeze la fiecare pas.

The main routine in Cpu1

Acesta este un scurt rezumat al rutinei main din Cpu1, clasa wrapper care se ocupă cu a înţelege argumentele folosite de utilizator în linia de comandă Java, şi apoi cu setarea modelului de procesor Cpu1 după cum urmează:

public void main(String argv[]) {

    Cmdline.analyse(..., argv);                                    // parse command line

    Elf elf[] = new Elf[Cmdline.args.length];
    for (int j = 0; j < Cmdline.args.length; j++) {                // încarcă fişierele executabile `ELF format' 
        String filename = Cmdline.args[j];
        elf[j] = new Elf(filename);
    }
    byte stack[] = new byte[STACK_END - STACK_START];              // pregăteşte zona de memorie stack din CPU

    CPU1 cpu = new CPU1();                                         // construieşte CPU
    {                                                              // iniţializează stiva
        cpu.memory.addRegion(stack, STACK_START, STACK_END);
        for (int j = 0; j < elf.length; j++) {                     // iniţializează codul programului
            cpu.memory.addRegion(elf[j].text, elf[j].text_start, elf[j].text_end);
        }
    }
    cpu.SP.write(STACK_END);                                       // setează pointerul stivei la început
    cpu.PC.write(elf[0].text_entry);                               // setează numărătoarea programului la primul punct
    cpu.run();                                                     // rulează simularea!
}

Se observă aici că main analizează linia de comandp folosing metoda Cmdline analyse, obţinând o listă de fişiere executabile al caror cod îl va rula.

ELF este o platforma cross standard utilizată în multe sisteme de operare folosite astazi şi este în formatul produs de compilatorii şi asamblatorii gcc MIPS.

Aceasta înseamnă ca apelează constructorul Elf la numele fiecăriu fişier, care analizează componentele fişierului si extrage informaţie precum punctele de entrz, locaţiile adreselor virtuale, etc., toate acestea fiind plasate in obiectul Elf ce rezultă în urma acestora.

În continuare, main contruieşte regiunea stivă în memorie si CPU, şi îi transmite unitaţii de memorie CPU informaţii despre stivă şi adresa virtuală planificata prin intermediul unui apel la metoda unităţii de memorie addRegion. Totodată, transmite unităţii de memorie informaţii despre implicaţiile codului care a fost cules din fişierele executabile ELF prin apeluri adiţionale la addRegion.

Ceea ce ramâne este să fie setate registrul poinerilor stivei din CPU SP la începutul stivei, setarea registrului PC la adresa entry pointului programului prevăzut- obţinut de la primul document demumit in linia de comandă- şi apoi este apelat noua metoda run a CPU.

Liniile următoare reprezintă tot ceea ce un programator trebuie sa stie despre Cpu1:

Secţiunea următoare explică ce inseamnă "rularea".

Modelul procesorului CPU

Următoarea secţiune cuprinde toate informaţiile necesare despre clasa procesorului CPU1. Secţiunea conţine un constructor şi o metodă.

Codul metodei run nu este foarte dificil. Este alcătuit în mare dintr-un singur loop:

public void run() {
    while (Clock.running()) {
         ... /* interiorul ciclului Von Neumann fetch-decode-execute */ ...
    }
}

Interiorul ciclului Von Neumann fetch-decode-execute:

// FETCH!

int pc  = PC.read();                                          // citeşte PC
int ir  = memory.read32be(pc);                                // citeşte instrucţiunile de la adresa dată de PC
IR.write(ir);                                                 // scrie instrucţiunile în IR
pc      = feAlu.execute(ALU_ADDU, pc, 4).c;                   // adaugă 4 la valoarea PC folosit adder
PC.write(pc);                                                 // ruta PC incrementează valoarea PC

// DECODE!

byte op = InstructionRegister.OPCODE(ir);                     // decodează opcode
DecodeReturnT conf = new DecodeReturnT();
{
    conf.op = op;                                             // decodează rezultatul la wires op,ir,pc
    conf.ir = ir;
    conf.pc = pc;                                             // NB: "original PC"+4 se află în conf.pc
}
switch(op) { 
  case 0:                                                     // tratează ALU ops

    conf.sssss = InstructionRegister.aluopSRC1(ir);           // decodează instrucţiunile fields rămase 
    conf.ttttt = InstructionRegister.aluopSRC2(ir);
    conf.ddddd = InstructionRegister.aluopDST (ir);
    conf.func  = InstructionRegister.aluopOP  (ir);

    Clock.increment(DECODE_LATENCY);                          // scrieţi aici updateul pentru decode

    // READ!                                                  // citeşte conţinutul registrilor

    RegReturnT r = register_unit.read(conf.sssss, conf.ttttt);

    // EXECUTE!

    AluReturnT s = alu.execute(conf.func, r.a, r.b);          // execută aritmetica

    // WRITE!

    register_unit.write(conf.ddddd, s.c);                     // atribuie rezultatul regiştrilor desemnaţi 
    break;                                                    // ESAC

Fiecare instrucţiune are un bloc condiţional(un bloc pentru fiecare opcode). Fragmentul de deasupra arată blocul dedicat operaţiilor ALU, care au opcode-ul 0.

Tipurile diferite de operaţii se disting după valorile funcţiei func din instrucţiune (ultimii 6 biţi de la cel capatul cuvântului cel mai puţin semnificativ din layoutul bigendian).

Toate funcţiile distincte din instrucţiunea IR sunt separate, inclusiv func, în secţiunea numită DECODE!, şi apoi funcţionalitatea instrucţiuniei este implementată in secţiunile din codul Java numite READ!, EXECUTE!, WRITE!