MIC-1: razlika između inačica
| Nije prikazana jedna međuinačica | |||
| Redak 43: | Redak 43: | ||
{| class="wikitable sortable" | {| class="wikitable sortable" | ||
|+ '''Instrukcijski skup MIC‑1''' | |+ '''Instrukcijski skup MIC‑1 (kategorizirano i obojano)''' | ||
! Mnemonic | ! Mnemonic | ||
! Encoding | ! Encoding | ||
! Instruction | ! Instruction | ||
! Semantics | ! Semantics | ||
! Kategorija | |||
|- | |- | ||
| LODD ‹Arg› | | style="background:#d1fae5" | LODD ‹Arg› | ||
| 0000xxxxxxxxxxxx | | 0000xxxxxxxxxxxx | ||
| Load Direct | | Load Direct | ||
| AC := Mem[X] | | AC := Mem[X] | ||
| style="background:#d1fae5" | Memorija | |||
|- | |- | ||
| STOD ‹Arg› | | style="background:#d1fae5" | STOD ‹Arg› | ||
| 0001xxxxxxxxxxxx | | 0001xxxxxxxxxxxx | ||
| Store Direct | | Store Direct | ||
| Mem[X] := AC | | Mem[X] := AC | ||
| style="background:#d1fae5" | Memorija | |||
|- | |- | ||
| ADDD ‹Arg› | | style="background:#bfdbfe" | ADDD ‹Arg› | ||
| 0010xxxxxxxxxxxx | | 0010xxxxxxxxxxxx | ||
| Add Direct | | Add Direct | ||
| AC := AC + Mem[X] | | AC := AC + Mem[X] | ||
| style="background:#bfdbfe" | Aritmetika | |||
|- | |- | ||
| SUBD ‹Arg› | | style="background:#bfdbfe" | SUBD ‹Arg› | ||
| 0011xxxxxxxxxxxx | | 0011xxxxxxxxxxxx | ||
| Subtract Direct | | Subtract Direct | ||
| AC := AC - Mem[X] | | AC := AC - Mem[X] | ||
| style="background:#bfdbfe" | Aritmetika | |||
|- | |- | ||
| JPOS ‹Arg› | | style="background:#fef9c3" | JPOS ‹Arg› | ||
| 0100xxxxxxxxxxxx | | 0100xxxxxxxxxxxx | ||
| Jump on non-negative | | Jump on non-negative | ||
| If AC ≥ 0, PC := X | | If AC ≥ 0, PC := X | ||
| style="background:#fef9c3" | Skok | |||
|- | |- | ||
| JZER ‹Arg› | | style="background:#fef9c3" | JZER ‹Arg› | ||
| 0101xxxxxxxxxxxx | | 0101xxxxxxxxxxxx | ||
| Jump on zero | | Jump on zero | ||
| If AC = 0, PC := X | | If AC = 0, PC := X | ||
| style="background:#fef9c3" | Skok | |||
|- | |- | ||
| JUMP ‹Arg› | | style="background:#fef9c3" | JUMP ‹Arg› | ||
| 0110xxxxxxxxxxxx | | 0110xxxxxxxxxxxx | ||
| Jump | | Jump | ||
| PC := X | | PC := X | ||
| style="background:#fef9c3" | Skok | |||
|- | |- | ||
| LOCO ‹Arg› | | style="background:#bfdbfe" | LOCO ‹Arg› | ||
| 0111xxxxxxxxxxxx | | 0111xxxxxxxxxxxx | ||
| Load Constant | | Load Constant | ||
| AC := X | | AC := X | ||
| style="background:#bfdbfe" | Aritmetika | |||
|- | |- | ||
| LODL ‹Arg› | | style="background:#d1fae5" | LODL ‹Arg› | ||
| 1000xxxxxxxxxxxx | | 1000xxxxxxxxxxxx | ||
| Load Local | | Load Local | ||
| AC := Mem[SP + X] | | AC := Mem[SP + X] | ||
| style="background:#d1fae5" | Memorija | |||
|- | |- | ||
| STOL ‹Arg› | | style="background:#d1fae5" | STOL ‹Arg› | ||
| 1001xxxxxxxxxxxx | | 1001xxxxxxxxxxxx | ||
| Store Local | | Store Local | ||
| Mem[SP + X] := AC | | Mem[SP + X] := AC | ||
| style="background:#d1fae5" | Memorija | |||
|- | |- | ||
| ADDL ‹Arg› | | style="background:#bfdbfe" | ADDL ‹Arg› | ||
| 1010xxxxxxxxxxxx | | 1010xxxxxxxxxxxx | ||
| Add Local | | Add Local | ||
| AC := AC + Mem[SP + X] | | AC := AC + Mem[SP + X] | ||
| style="background:#bfdbfe" | Aritmetika | |||
|- | |- | ||
| SUBL ‹Arg› | | style="background:#bfdbfe" | SUBL ‹Arg› | ||
| 1011xxxxxxxxxxxx | | 1011xxxxxxxxxxxx | ||
| Subtract Local | | Subtract Local | ||
| AC := AC - Mem[SP + X] | | AC := AC - Mem[SP + X] | ||
| style="background:#bfdbfe" | Aritmetika | |||
|- | |- | ||
| JNEG ‹Arg› | | style="background:#fef9c3" | JNEG ‹Arg› | ||
| 1100xxxxxxxxxxxx | | 1100xxxxxxxxxxxx | ||
| Jump on negative | | Jump on negative | ||
| If AC < 0, PC := X | | If AC < 0, PC := X | ||
| style="background:#fef9c3" | Skok | |||
|- | |- | ||
| JNZE ‹Arg› | | style="background:#fef9c3" | JNZE ‹Arg› | ||
| 1101xxxxxxxxxxxx | | 1101xxxxxxxxxxxx | ||
| Jump unless zero | | Jump unless zero | ||
| If AC ≠ 0, PC := X | | If AC ≠ 0, PC := X | ||
| style="background:#fef9c3" | Skok | |||
|- | |- | ||
| CALL ‹Arg› | | style="background:#fecaca" | CALL ‹Arg› | ||
| 1110xxxxxxxxxxxx | | 1110xxxxxxxxxxxx | ||
| Call | | Call | ||
| SP := SP - 1; Mem[SP] := PC; PC := X | | SP := SP - 1; Mem[SP] := PC; PC := X | ||
| style="background:#fecaca" | Kontrola | |||
|- | |- | ||
| PSHI | | style="background:#fed7aa" | PSHI | ||
| 1111000000000000 | | 1111000000000000 | ||
| Push Indirect | | Push Indirect | ||
| SP := SP - 1; Mem[SP] := Mem[AC] | | SP := SP - 1; Mem[SP] := Mem[AC] | ||
| style="background:#fed7aa" | Stog | |||
|- | |- | ||
| POPI | | style="background:#fed7aa" | POPI | ||
| 1111001000000000 | | 1111001000000000 | ||
| Pop Indirect | | Pop Indirect | ||
| Mem[AC] := Mem[SP]; SP := SP + 1 | | Mem[AC] := Mem[SP]; SP := SP + 1 | ||
| style="background:#fed7aa" | Stog | |||
|- | |- | ||
| PUSH | | style="background:#fed7aa" | PUSH | ||
| 1111010000000000 | | 1111010000000000 | ||
| Push | | Push | ||
| SP := SP - 1; Mem[SP] := AC | | SP := SP - 1; Mem[SP] := AC | ||
| style="background:#fed7aa" | Stog | |||
|- | |- | ||
| POP | | style="background:#fed7aa" | POP | ||
| 1111011000000000 | | 1111011000000000 | ||
| Pop | | Pop | ||
| AC := Mem[SP]; SP := SP + 1 | | AC := Mem[SP]; SP := SP + 1 | ||
| style="background:#fed7aa" | Stog | |||
|- | |- | ||
| RETN | | style="background:#fecaca" | RETN | ||
| 1111100000000000 | | 1111100000000000 | ||
| Return | | Return | ||
| PC := Mem[SP]; SP := SP + 1 | | PC := Mem[SP]; SP := SP + 1 | ||
| style="background:#fecaca" | Kontrola | |||
|- | |- | ||
| SWAP | | style="background:#bfdbfe" | SWAP | ||
| 1111101000000000 | | 1111101000000000 | ||
| Swap AC & SP | | Swap AC & SP | ||
| AC :=: SP | | AC :=: SP | ||
| style="background:#bfdbfe" | Aritmetika | |||
|- | |- | ||
| INSP ‹Arg› | | style="background:#fed7aa" | INSP ‹Arg› | ||
| 11111100yyyyyyyy | | 11111100yyyyyyyy | ||
| Increment SP | | Increment SP | ||
| SP := SP + Y | | SP := SP + Y | ||
| style="background:#fed7aa" | Stog | |||
|- | |- | ||
| DESP ‹Arg› | | style="background:#fed7aa" | DESP ‹Arg› | ||
| 11111110yyyyyyyy | | 11111110yyyyyyyy | ||
| Decrement SP | | Decrement SP | ||
| SP := SP - Y | | SP := SP - Y | ||
| style="background:#fed7aa" | Stog | |||
|- | |- | ||
| HALT | | style="background:#fecaca" | HALT | ||
| 1111111100000000 | | 1111111100000000 | ||
| Halt | | Halt | ||
| Halt processor | | Halt processor | ||
| style="background:#fecaca" | Kontrola | |||
|} | |} | ||
Posljednja izmjena od 13. srpanj 2026. u 11:25
MIC‑1 je mikroarhitektura koju je Andrew S. Tanenbaum osmislio i predstavio u svojoj knjizi Structured Computer Organization (prvo izdanje 1976., kasnije brojna proširena izdanja).
Povijest i razvoj
Razvoj mikroarhitekture MIC‑1 usko je povezan s nastankom udžbenika Structured Computer Organization američkog računalnog znanstvenika Andrewa S. Tanenbauma. Tijekom 1970‑ih i ranih 1980‑ih Tanenbaum je uočio da se studenti računalnih znanosti često susreću s velikim jazom između apstraktnih programskih koncepata i stvarnog funkcioniranja procesora na razini mikroinstrukcija. Kako bi premostio taj jaz, osmislio je jednostavan, ali potpuno funkcionalan model mikroprogramiranog procesora — MIC‑1.
Prvo izdanje
Prvo izdanje knjige, objavljeno 1976., predstavilo je MIC‑1 kao temeljni obrazovni alat za razumijevanje mikroprogramiranja. U kasnijim izdanjima Tanenbaum je model dodatno usavršavao, ali je zadržao njegovu izvorno zamišljenu jednostavnost: jedinstvena sabirnica, mali skup registara, osnovni ALU i mikroprogramska upravljačka jedinica. Time je MIC‑1 postao idealan za demonstraciju kako se instrukcije višeg nivoa razlažu u mikrooperacije.
MIC-2
Kako je nastava arhitekture računala evoluirala, MIC‑1 je dobio i svoje proširenje — MIC‑2, model s dvostrukom sabirnicom koji omogućuje paralelniji tok podataka. Paralelno s time Tanenbaum je razvio i IJVM, pojednostavljeni instrukcijski skup inspiriran Java Virtual Machineom, kako bi studenti mogli vidjeti kako se virtualne instrukcije prevode u mikroinstrukcije MIC‑1 procesora.
Tijekom 1990‑ih i 2000‑ih MIC‑1 je postao standardni dio sveučilišnih kolegija diljem svijeta. Brojni simulacijski alati, vizualizatori mikroinstrukcija i studentski projekti dodatno su učvrstili njegov status kao jednog od najuspješnijih didaktičkih modela u povijesti računalne arhitekture. Unatoč jednostavnosti, MIC‑1 i danas služi kao referentni primjer mikroprogramiranog procesora, posebno u kontekstu usporedbe s modernim RISC arhitekturama koje se oslanjaju na hardverski upravljane kontrolne jedinice.
Opis
MIC‑1 je jednostavan, mikroprogramirani procesor čija je glavna svrha didaktička: omogućiti studentima da prate kako se instrukcije višeg nivoa razlažu u mikrooperacije i kako se one izvršavaju nad internim registrima i sabirnicama.
Arhitektura
MIC‑1 se sastoji od nekoliko ključnih komponenti[1]:
- Sabirnica] (bus) — jedinstvena interna sabirnica preko koje se prenose podaci između registara i ALU‑a.
- Registri — ukupno 16 x 16 bitnih registara uključuju PC, MAR, MDR, IR, H, 5 x registara s fiksnim vrijednostima te skup od 6 općih registara (A,B,C,D,E,F).
- ALU — jednostka za aritmetičko‑logičke operacije, s podrškom za osnovne operacije poput zbrajanja, oduzimanja i logičkih funkcija.
- Upravljačka jedinica — mikroprogramirana; mikroinstrukcije se čuvaju u kontrolnoj memoriji i određuju tok podataka i aktivaciju kontrolnih signala.
- Memorija — modelirana kao jednostavna RAM jedinica dostupna preko MAR/MDR sklopova.
Mikroinstrukcije
Svaka mikroinstrukcija MIC‑1 procesora sastoji se od:
- polja za odabir izvora podataka na sabirnici
- polja za odabir odredišnog registra
- ALU kontrolnih bitova
- kontrolnih signala za memoriju
- adrese sljedeće mikroinstrukcije (sekvenciranje)
Ovaj format omogućuje studentima da jasno vide kako se složene instrukcije strojnog jezika razlažu na niz mikrooperacija. Za mikroinstrukcije Tanenbaum je razvio posebni assemblerski jezik MAL, s kojim se mogao uređivati mikroprogram za MIC-1. U sebi je sadržavao sve osnovne narebe s kojim se moglo upravljati s mikrosekvencerom.[2]
Instrukcijski skup
| Mnemonic | Encoding | Instruction | Semantics | Kategorija |
|---|---|---|---|---|
| LODD ‹Arg› | 0000xxxxxxxxxxxx | Load Direct | AC := Mem[X] | Memorija |
| STOD ‹Arg› | 0001xxxxxxxxxxxx | Store Direct | Mem[X] := AC | Memorija |
| ADDD ‹Arg› | 0010xxxxxxxxxxxx | Add Direct | AC := AC + Mem[X] | Aritmetika |
| SUBD ‹Arg› | 0011xxxxxxxxxxxx | Subtract Direct | AC := AC - Mem[X] | Aritmetika |
| JPOS ‹Arg› | 0100xxxxxxxxxxxx | Jump on non-negative | If AC ≥ 0, PC := X | Skok |
| JZER ‹Arg› | 0101xxxxxxxxxxxx | Jump on zero | If AC = 0, PC := X | Skok |
| JUMP ‹Arg› | 0110xxxxxxxxxxxx | Jump | PC := X | Skok |
| LOCO ‹Arg› | 0111xxxxxxxxxxxx | Load Constant | AC := X | Aritmetika |
| LODL ‹Arg› | 1000xxxxxxxxxxxx | Load Local | AC := Mem[SP + X] | Memorija |
| STOL ‹Arg› | 1001xxxxxxxxxxxx | Store Local | Mem[SP + X] := AC | Memorija |
| ADDL ‹Arg› | 1010xxxxxxxxxxxx | Add Local | AC := AC + Mem[SP + X] | Aritmetika |
| SUBL ‹Arg› | 1011xxxxxxxxxxxx | Subtract Local | AC := AC - Mem[SP + X] | Aritmetika |
| JNEG ‹Arg› | 1100xxxxxxxxxxxx | Jump on negative | If AC < 0, PC := X | Skok |
| JNZE ‹Arg› | 1101xxxxxxxxxxxx | Jump unless zero | If AC ≠ 0, PC := X | Skok |
| CALL ‹Arg› | 1110xxxxxxxxxxxx | Call | SP := SP - 1; Mem[SP] := PC; PC := X | Kontrola |
| PSHI | 1111000000000000 | Push Indirect | SP := SP - 1; Mem[SP] := Mem[AC] | Stog |
| POPI | 1111001000000000 | Pop Indirect | Mem[AC] := Mem[SP]; SP := SP + 1 | Stog |
| PUSH | 1111010000000000 | Push | SP := SP - 1; Mem[SP] := AC | Stog |
| POP | 1111011000000000 | Pop | AC := Mem[SP]; SP := SP + 1 | Stog |
| RETN | 1111100000000000 | Return | PC := Mem[SP]; SP := SP + 1 | Kontrola |
| SWAP | 1111101000000000 | Swap AC & SP | AC :=: SP | Aritmetika |
| INSP ‹Arg› | 11111100yyyyyyyy | Increment SP | SP := SP + Y | Stog |
| DESP ‹Arg› | 11111110yyyyyyyy | Decrement SP | SP := SP - Y | Stog |
| HALT | 1111111100000000 | Halt | Halt processor | Kontrola |
MIC‑1 se često koristi zajedno s jednostavnim modelom strojnog jezika nazvanim IJVM (Integer Java Virtual Machine). IJVM je podskup JVM‑a, prilagođen za obrazovne svrhe, a MIC‑1 služi kao njegova hardverska implementacija.
Instrukcije poput IADD, ILOAD, ISTORE, GOTO i INVOKEVIRTUAL demonstriraju kako se visokonivojske operacije prevode u mikroinstrukcije.