Juhtplokk on arvutites keskprotsessori (CPU) põhikomponent, mis saab programmi käivitamise ajal toiminguid juhtida töötleja / arvuti. Juhtploki peamine ülesanne on arvuti mälust juhiste toomine ja täitmine. See saab kasutajalt sisestusjuhise / teabe ja teisendab selle juhtimissignaalid , mis antakse seejärel protsessorile edasiseks täitmiseks. See on lisatud John Neumanni väljatöötatud Von Neumanni arhitektuuri osana. See vastutab ajastussignaalide ja juhtimissignaalide edastamise eest ning juhib programmi täitmist protsessori poolt. See on moodsate arvutite protsessori sisemise osana. Selles artiklis kirjeldatakse täielikku teavet juhtploki kohta.
Mis on juhtplokk?
Komponent, mis võtab kasutajalt vastu sisendsignaali / informatsiooni / juhise ja muundub juhtsignaalideks protsessori täitmiseks. See juhib ja suunab põhimälu, aritmeetika- ja loogikaüksust (ALU), sisend- ja väljundseadmeid ning vastutab ka arvuti protsessorile saadetud juhiste eest. See tõmbab juhised põhimälu protsessori käskude registrisse, mis sisaldab registri sisu.
Juhtploki plokkskeem
Juhtplokk muundab sisendi juhtsignaalideks ja saadetakse seejärel protsessorile ning juhib programmi täitmist. Tehtavaid toiminguid suunab arvutis olev protsessor. Peamiselt keskprotsessor (CPU) ja Graafiline töötlemise üksus (GPU) nõuab sisemise osana juhtplokki. Juhtploki plokkskeem on näidatud ülal.
Juhtimisseadme komponendid
Selle seadme komponendid on juhised registrid , juhtsignaalid protsessoris, juhtimissignaalid siinilt / bussilt, juhtimisbussi, sisendlipud ja kellasignaalid.
Juhtmega juhtmeta komponendid on käsuregister (sisaldab opkoodi ja aadressivälja), ajastusüksus, juhtimisolek generaator , juhtsignaali genereerimise maatriks ja käskude dekooder.
Micro programmeeritud juhtploki komponentideks on järgmine aadressigeneraator, juhtimisaadresside register, juhtmälu ja juhtimisandmete register.
Funktsioonid
The juhtseadme funktsioonid sisaldama järgmist.
- See juhib protsessori ja muude seadmete vahelise andmevoo liikumist.
- See suudab tõlgendada juhiseid ja kontrollida protsessori andmevoogu.
- See genereerib juhtsignaalide jada käskude registrist vastuvõetud käskude või käskude põhjal.
- Selle ülesandeks on kontrollida arvuti protsessoris selliseid täitmisüksusi nagu ALU, andmepuhvreid ja registreid.
- Sellel on võimalus tuua, dekodeerida, käsitseda täitmist ja salvestada tulemusi.
- See ei saa andmeid töödelda ja salvestada
- Andmete edastamiseks suhtleb see sisend- ja väljundseadmetega ning juhib kõiki arvuti üksusi.
Juhtploki disain
Selle kujunduse saab teha kahe abil juhtseadme tüübid mis sisaldavad järgmist.
- Riistraadipõhine
- Mikroprogrammeeritud (ühetasandiline ja kahetasandiline)
Juhtmega juhtplokk
Juhtmega juhtploki põhikonstruktsioon on näidatud eespool. Seda tüüpi genereerib juhtimissignaalid spetsiaalne riistvara loogikaahel ilma vooluahela struktuuri muutmata. Selles ei saa genereeritud signaali protsessoris täitmiseks muuta.
Opkoodi põhiandmed (käsu toimingukood saadetakse dekodeerimiseks käsudekoodrile. Käsk dekooder on dekoodrite komplekt erinevat tüüpi andmete dekodeerimiseks opkoodis. Selle tulemuseks on väljundsignaalid, mis sisaldavad aktiivsignaalide väärtusi, mis antakse maatriksigeneraatori sisendina, et genereerida arvuti protsessori poolt programmi käivitamiseks juhtsignaale.
Juhtmetel põhinev juhtplokk
Maatriksigeneraator annab juhtploki olekud ja protsessorist väljuvad signaalid (katkestussignaalid). Maatriks on ehitatud programmeeritav loogikamassiiv . Maatriksigeneraatori genereeritud juhtsignaalid antakse järgmise generaatori maatriksi sisendina ja ühendatakse ristkülikukujulisi mustreid sisaldava ajastusüksuse ajastussignaalidega.
Uue käsu toomiseks saab juhtplokk uue käsu täitmise algstaadiumiks. Juhtplokk jääb algstaadiumisse või esimesse etappi seni, kuni arvuti ajastussignaalid, sisendsignaalid ja käskude olekud ei muutu. Juhtseadme oleku muutust saab tõsta, kui mõnes genereeritud signaalis on mingeid muutusi.
Välise signaali või katkestuse korral läheb juhtplokk järgmisse olekusse ja teostab katkestussignaali töötlemise. Lippude ja olekute abil valitakse soovitud olekud käsu täitmise tsükli täitmiseks.
Viimases olekus tõmbab juhtplokk järgmise käsu ja saadab väljundi programmiloendurile, seejärel mäluaadressiregistrisse, puhvriregistrisse ja seejärel käsuregistrisse käsu lugemiseks. Lõpuks, kui viimane käsk (mille juhtseade tõmbab) on lõpukäsk, siis läheb see protsessori tööolekusse ja ootab, kuni kasutaja juhib järgmist programmi.
Mikroprogrammeeritud juhtplokk
Seda tüüpi juhtsalvestust kasutatakse programmi käivitamisel kodeeritud juhtsignaalide salvestamiseks. Juhtimissignaali ei genereerita kohe ja see dekodeeritakse, kuna mikroprogramm salvestab juhtvälja aadressivälja. Kogu protsess on ühtne tasand.
Mikrooperatsioonid tehakse mikrokäskude täitmiseks programmis. Micro programmeeritud juhtploki plokkskeem on näidatud ülal. Diagrammilt saadakse mikrokäsu aadress juhtmälu aadressiregistrist. Kogu juhtseadme teave on püsivalt salvestatud juhtmällu nimega ROM.
Mikroprogrammeeritud juhtimisseade
Juhtmälust pärinevat mikrokäsku hoiab juhtimisregister. Kuna mikrokäsk on juhtsõna kujul (sisaldab binaarseid kontrollväärtusi), mis vajab andmetöötluseks ühe või enama mikrooperatsiooni tegemist.
Mikrokäskude täitmise ajal arvutas järgmine aadressigeneraator mikrokäskude järgmise aadressi ja saatis seejärel kontrolliaadresside registrisse järgmise mikrokäskude lugemiseks.
Mikroprogrammi mikrooperatsioonide jada teostab järgmine aadressigeneraator ja see toimib mikroprogrammi sekvenaatorina, et saada jada aadress, st lugeda juhtmälust.
Juhtploki Verilogi kood
Allpool on näidatud juhtploki Verilogi kood.
`sisaldab' prj_definition.v '
moodul CONTROL_UNIT (MEM_DATA, RF_DATA_W, RF_ADDR_W, RF_ADDR_R1, RF_ADDR_R2, RF_READ, RF_WRITE, ALU_OP1, ALU_OP2, ALU_OPRN, MEM_ADDR, MEM_READ, MEM_WRITE, RF_DATA_R1, RF_DATA_1
// Väljundsignaalid
// Registrifaili väljundid
väljund [`DATA_INDEX_LIMIT: 0] RF_DATA_W
väljund [`ADDRESS_INDEX_LIMIT: 0] RF_ADDR_W, RF_ADDR_R1, RF_ADDR_R2
väljund RF_READ, RF_WRITE
// ALU väljundid
väljund [`DATA_INDEX_LIMIT: 0] ALU_OP1, ALU_OP2
väljund [`ALU_OPRN_INDEX_LIMIT: 0] ALU_OPRN
// Mälu väljundid
väljund [`ADDRESS_INDEX_LIMIT: 0] MEM_ADDR
väljund MEM_READ, MEM_WRITE
// Sisendsignaalid
sisend [`DATA_INDEX_LIMIT: 0] RF_DATA_R1, RF_DATA_R2, ALU_RESULT
sisend ZERO, CLK, RST
// Inout signaal
väljapoole [`DATA_INDEX_LIMIT: 0] MEM_DATA
// Riigivõrgud
traat [2: 0] proc_state
// hoiab programmi loenduri väärtust, salvestab praeguse käsu, korstnate osuregistri
reg MEM_READ, MEM_WRITE
reg MEM_ADDR
reg ALU_OP1, ALU_OP2
reg ALU_OPRN
reg RF_ADDR_W, RF_ADDR_R1, RF_ADDR_R2
reg RF_DATA_W
reg [1: 0] olek, järgmine jaam
PROC_SM oleku_masin (.STATE (proc_state), CLK (CLK), RST (RST))
alati @ (posedge CLK)
algama
kui (RST)
riik<= RST
muud
riik<= next_state
lõpp
alati @ (osariik)
algama
MEM_READ = 1’b0 MEM_WRITE = 1’b0 MEM_ADDR = 1’b0
ALU_OP1 = 1’b0 ALU_OP2 = 1’b0 ALU_OPRN = 1’b0
RF_ADDR_R1 = 1’b0 RF_ADDR_R2 = 1’b0 RF_ADDR_W = 1’b0 RF_DATA_W = 1’b0
juhtum (osariik)
`PROC_FETCH: alusta
next_state = 'PROC_DECODE
MEM_READ = 1’b1
RF_ADDR_R1 = 1’b0 RF_ADDR_R2 = 1’b0
RF_ADDR_W = 1’b1
lõpp
'PROC_DECODE: alusta
next_state = 'PROC_EXE
MEM_ADDR = 1’b1
ALU_OP1 = 1’b1 ALU_OP2 = 1’b1 ALU_OPRN = 1’b1
MEM_WRITE = 1’b1
RF_ADDR_R1 = 1’b1 RF_ADDR_R2 = 1’b1
lõpp
'PROC_EXE: alusta
next_state = 'PROC_MEM
ALU_OP1 = 1’b1 ALU_OP2 = 1’b1 ALU_OPRN = 1’b1
RF_ADDR_R1 = 1’b0
lõpp
`PROC_MEM: alusta
järgmine jaam = 'PROC_WB
MEM_READ = 1’b1 MEM_WRITE = 1’b0
lõpp
'PROC_WB: alusta
next_state = 'PROC_FETCH
MEM_READ = 1’b1 MEM_WRITE = 1’b0
lõpp
kott
lõpp
lõppmoodul
moodul PROC_SM (STATE, CLK, RST)
// sisendite loend
sisend CLK, RST
// väljundite loend
väljund [2: 0] STATE
// sisendloend
sisend CLK, RST
// väljundiloend
väljund STATE
reg [2: 0] RIIK
reg [1: 0] olek
reg [1: 0] järgmine jaam
reg PC_REG, INST_REG, SP_REF
`define PROC_FETCH 3'h0
`define PROC_DECODE 3'h1
`define PROC_EXE 3'h2
`määrake PROC_MEM 3'h3
`määrake PROC_WB 3'h4
// oleku algatamine
initsiaalne
algama
osariik = 2’bxx
next_state = 'PROC_FETCH
lõpp
// lähtestage signaali käitlemine
alati @ (posedge RST)
algama
olek = 'PROC_FETCH
next_state = 'PROC_FETCH
lõpp
alati @ (posedge CLK)
algama
riik = järgmine jaam
lõpp
alati @ (osariik)
algama
kui (olek === 'PROC_FETCH)
algama
next_state = 'PROC_DECODE
print_instruction (INST_REG)
lõpp
kui (olek === 'PROC_DECODE)
algama
next_state = 'PROC_EXE
lõpp
kui (olek === 'PROC_EXE)
algama
next_state = 'PROC_MEM
print_instruction (SP_REF)
lõpp
kui (olek === 'PROC_MEM)
algama
järgmine jaam = 'PROC_WB
lõpp
kui (olek === 'PROC_WB)
algama
next_state = 'PROC_FETCH
print_juhis (PC_REG)
lõpp
lõpp
ülesande print_juhis
sisend [`DATA_INDEX_LIMIT: 0] inst
reg [5: 0] opkood
reg [4: 0] rs
reg [4: 0] toatemperatuur
reg [4: 0]
reg [4: 0] shamt reg [5: 0] funct reg [15: 0] kohene reg [25: 0] aadress
algama
// parsige käsk
// R-tüüp
{opcode, rs, rt, rd, shamt, funct} = inst
// I-tüüp
{opcode, rs, rt, kohe} = inst
// J-tüüp
{opcode, aadress} = inst
$ write ('@% 6dns -> [0X% 08h]', $ time, inst)
juhtum (opcode) // R-tüüp
6'h00: algus
juhtum (funktsioon)
6’h20: $ write („lisa r [% 02d], r [% 02d], r [% 02d]”, rs, rt, rd)
6’h22: $ kirjuta („sub r [% 02d], r [% 02d], r [% 02d]”, rs, rt, rd)
6’h2c: $ write („mul r [% 02d], r [% 02d], r [% 02d]”, rs, rt, rd)
6’h24: $ kirjuta (“ja r [% 02d], r [% 02d], r [% 02d]”, rs, rt, rd)
6’h25: $ kirjuta („või r [% 02d], r [% 02d], r [% 02d]”, rs, rt, rd)
6’h27: $ write (“ega r [% 02d], r [% 02d], r [% 02d]”, rs, rt, rd)
6’h2a: $ write („slt r [% 02d], r [% 02d], r [% 02d]”, rs, rt, rd)
6’h00: $ write („sll r [% 02d],% 2d, r [% 02d]”, rs, shamt, rd)
6’h02: $ write („srl r [% 02d], 0X% 02h, r [% 02d]”, rs, shamt, rd)
6’h08: $ write („jr r [% 02d]”, rs)
vaikimisi: $ write (“”)
kott
lõpp
// I-tüüp
6’h08: $ write („addi r [% 02d], r [% 02d], 0X% 04h”, rs, rt, kohe)
6’h1d: $ write („muli r [% 02d], r [% 02d], 0X% 04h”, rs, rt, kohe)
6’h0c: $ write („andi r [% 02d], r [% 02d], 0X% 04h”, rs, rt, kohe)
6’h0d: $ write („ori r [% 02d], r [% 02d], 0X% 04h”, rs, rt, kohe)
6’h0f: $ write („lui r [% 02d], 0X% 04h”, rt, kohe)
6’h0a: $ write („slti r [% 02d], r [% 02d], 0X% 04h”, rs, rt, kohe)
6’h04: $ write („beq r [% 02d], r [% 02d], 0X% 04h”, rs, rt, kohe)
6’h05: $ kirjuta („bne r [% 02d], r [% 02d], 0X% 04h”, rs, rt, kohe)
6’h23: $ write („lw r [% 02d], r [% 02d], 0X% 04h”, rs, rt, kohe)
6’h2b: $ write („sw r [% 02d], r [% 02d], 0X% 04h”, rs, rt, kohe)
// J-tüüp
6’h02: $ write („jmp 0X% 07h”, aadress)
6’h03: $ write („jal 0X% 07h”, aadress)
6’h1b: $ write (“push”)
6’h1c: $ write (“pop”)
vaikimisi: $ write (“”)
kott
$ kirjuta (“ n”)
lõpp
lõppülesanne
lõppmoodul
KKK
1). Mis on juhtploki töö?
Juhtploki töö on suunata andmevoog või juhised arvuti protsessori poolt teostamiseks. See juhib, haldab ja koordineerib põhimälu, ALU-d, registreid, sisend- ja väljundüksusi. See tõmbab juhised ja genereerib käivitamiseks juhtimissignaalid.
2). Mis on kontrollmälu?
Juhtmälu on tavaliselt RAM või ROM juhtimisregistri aadressi ja andmete salvestamiseks.
3). Mis on Wilkesi juhtplokk?
Järjestikune ja kombineeritud vooluahelad juhtmega juhtseadme asendatakse Wilkesi juhtplokiga. See kasutab salvestusüksust mikroprogrammi käskude järjestuste salvestamiseks.
4). Mis on juhtmega juhtmega seade?
Juhtmega juhtplokk genereerib juhtimissignaalid, muutudes igas taktis ühest olekust teise olekusse ilma vooluahela füüsiliste muutusteta. Juhtimissignaalide genereerimine sõltub käsuregistrist, dekooderist ja katkestussignaalidest.
5). Mis on kontrollmälu?
Juhtimisseadme teave või andmed on ajutiselt või jäädavalt salvestatud juhtmällu.
Juhtmälu on kahte tüüpi. Need on muutmälu (RAM) ja kirjutuskaitstud mälu (ROM).
Seega on see kõik definitsiooni, komponentide, kujunduse, diagrammi, funktsioonide ja juhtseadme tüübid . Siin on teile küsimus: 'Mis on kontrolliaadresside registri eesmärk?'
