Ang control unit ay ang pangunahing sangkap ng isang sentral na yunit sa pagpoproseso (CPU) sa mga computer na maaaring magdirekta ng mga pagpapatakbo sa panahon ng pagpapatupad ng isang programa ng ang processor / computer Ang pangunahing pag-andar ng control unit ay upang makuha at isagawa ang mga tagubilin mula sa memorya ng isang computer. Natatanggap nito ang tagubilin / impormasyon ng pag-input mula sa gumagamit at ginawang ito control signal , na pagkatapos ay ibibigay sa CPU para sa karagdagang pagpapatupad. Kasama ito bilang isang bahagi ng arkitekturang Von Neumann na binuo ni John Neumann. Responsable ito para sa pagbibigay ng mga signal ng tiyempo, at kontrolin ang mga signal at ididirekta ang pagpapatupad ng isang programa ng CPU. Ito ay kasama bilang isang panloob na bahagi ng CPU sa mga modernong computer. Inilalarawan ng artikulong ito ang kumpletong impormasyon tungkol sa control unit.
Ano ang Control Unit?
Ang bahagi na tumatanggap ng input signal / impormasyon / tagubilin mula sa gumagamit at nagko-convert sa control signal para sa pagpapatupad sa CPU. Kinokontrol at dinidirekta nito ang pangunahing memorya, arithmetic & logic unit (ALU), mga aparato ng pag-input at output, at responsable din para sa mga tagubilin na ipinadala sa CPU ng isang computer. Kinukuha nito ang mga tagubilin mula sa pangunahing memorya ng isang processor at ipinadala sa rehistro ng tagubilin ng processor, na naglalaman ng mga nilalaman ng rehistro.
Control Diagram ng Block ng Unit
Ang control unit ay nagko-convert ng input sa control signal at pagkatapos ay ipinadala sa processor at dinidirekta ang pagpapatupad ng isang programa. Ang mga pagpapatakbo na kailangang gampanan ay ididirekta ng processor sa computer. Pangunahin ang Central Processing Unit (CPU) at Yunit ng Pagproseso ng grapiko Ang (GPU) ay nangangailangan ng isang control unit bilang panloob na bahagi. Ang block diagram ng control unit ay ipinapakita sa itaas.
Mga Bahagi ng isang Yunit ng Pagkontrol
Ang mga bahagi ng yunit na ito ay tagubilin mga rehistro , control signal sa loob ng CPU, control signal sa / mula sa bus, control bus, input flags, at signal ng orasan.
Ang mga bahagi ng Hardwired control unit ay rehistro ng pagtuturo (naglalaman ng opcode at address field), yunit ng oras, estado ng kontrol generator , kontrolin ang pagbuo ng signal matrix, at decoder ng tagubilin.
Ang mga bahagi ng unit ng control na na-program na Micro ay ang susunod na generator ng address, isang rehistro ng kontrol ng address, memorya ng kontrol, at rehistro ng data ng kontrol.
Mga pagpapaandar
Ang mga pag-andar ng control unit isama ang sumusunod.
- Dinidirekta nito ang daloy ng pagkakasunud-sunod ng data sa pagitan ng processor at iba pang mga aparato.
- Maaari nitong bigyang-kahulugan ang mga tagubilin at kinokontrol ang daloy ng data sa processor.
- Bumubuo ito ng pagkakasunud-sunod ng mga signal ng kontrol mula sa mga natanggap na tagubilin o utos mula sa rehistro ng pagtuturo.
- Responsibilidad nitong kontrolin ang mga yunit ng pagpapatupad tulad ng ALU, mga buffer ng data, at pagrehistro sa CPU ng isang computer.
- Ito ay may kakayahang makuha, mag-decode, hawakan ang pagpapatupad, at mag-imbak ng mga resulta.
- Hindi nito maproseso at maiimbak ang data
- Upang ilipat ang data, nakikipag-usap ito sa mga input at output na aparato at kinokontrol ang lahat ng mga yunit ng computer.
Disenyo ng Control Unit
Ang disenyo ng ito ay maaaring gawin gamit ang dalawa mga uri ng isang control unit na kasama ang sumusunod.
- Batay sa Hardwire
- Nakabatay sa microprogrammed (single-level at two-level)
Hardwired Control Unit
Ang pangunahing disenyo ng isang hardwired control unit ay ipinapakita sa itaas. Sa ganitong uri, ang mga signal ng control ay nabuo ng isang espesyal na hardware circuit ng lohika nang walang anumang pagbabago sa istraktura ng circuit. Sa ito, ang nabuong signal ay hindi maaaring mabago para sa pagpapatupad sa processor.
Ang pangunahing data ng isang opcode (ang code ng pagpapatakbo ng isang tagubilin ay ipinadala sa decoder ng pagtuturo para sa pag-decode. Ang tagubilin decoder ay ang hanay ng mga decoder upang mai-decode ang iba't ibang mga uri ng data sa opcode. Nagreresulta ito sa mga signal ng output na naglalaman ng mga halaga ng mga aktibong signal na ibinibigay bilang input sa matrix generator upang makabuo ng mga signal ng kontrol para sa pagpapatupad ng isang programa ng processor ng computer.
Batay sa Hardwire unit ng Control
Nagbibigay ang generator ng matrix ng mga estado ng mga yunit ng kontrol at mga signal mula sa processor (makagambala na mga signal). Ang Matrix ay itinayo bilang ang programmable array ng lohika . Ang mga signal ng control na nabuo ng matrix generator ay ibinibigay bilang input sa susunod na generator matrix at pinagsasama sa mga signal ng tiyempo ng yunit ng tiyempo na naglalaman ng mga hugis-parihaba na pattern.
Para sa pagkuha ng bagong tagubilin, ang control unit ay nagiging isang paunang yugto para sa pagpapatupad ng bagong tagubilin. Ang control unit ay mananatili sa paunang yugto o unang yugto hangga't ang mga signal ng tiyempo, mga signal ng pag-input, at mga estado ng tagubilin ng isang computer ay hindi nagbabago. Ang pagtaas sa estado ng control unit ay maaaring itaas kung mayroong anumang pagbabago sa alinman sa mga nabuong signal.
Kapag nangyari ang isang panlabas na signal o nakakagambala, ang control unit ay pupunta sa susunod na estado at isinasagawa ang pagproseso ng makagambalang signal. Ginagamit ang mga watawat at estado upang piliin ang nais na mga estado upang maisagawa ang ikot ng pagpapatupad ng tagubilin.
Sa huling estado, kinukuha ng control unit ang susunod na tagubilin at ipinapadala ang output sa counter ng programa, pagkatapos ay sa rehistro ng address ng memorya, sa rehistro ng buffer, at pagkatapos ay sa rehistro ng tagubilin upang mabasa ang tagubilin. Sa wakas, kung ang huling tagubilin (na kinukuha ng control unit) ay pagtatapos ng tagubilin, pagkatapos ay pupunta ito sa operating state ng processor at maghintay hanggang sa idirekta ng gumagamit ang susunod na programa.
Micro Programmed Control Unit
Sa ganitong uri, ang control store ay ginagamit upang mag-imbak ng mga signal ng kontrol na naka-encode sa pagpapatupad ng isang programa. Ang signal ng control ay hindi nabuo kaagad at na-decode dahil ang microprogram ay nag-iimbak ng patlang sa control store. Ang buong proseso ay isang solong antas.
Ang mga micro-operasyon ay tapos na para sa pagpapatupad ng mga micro-tagubilin sa programa. Ang block diagram ng Micro programmed control unit ay ipinapakita sa itaas. Mula sa diagram, ang address ng micro-instruction ay nakuha mula sa rehistro ng memorya ng control memory. Ang lahat ng impormasyon ng control unit ay permanenteng nakaimbak sa control memory na tinatawag na ROM.
Batay sa Mikroprogrammed Control Unit
Ang micro-tagubilin mula sa memorya ng kontrol ay hawak ng control register. Dahil ang micro-pagtuturo ay nasa anyo ng control word (naglalaman ng mga halaga ng binary control) na nangangailangan ng 1 o higit pang mga micro-operasyon na dapat gampanan para sa pagproseso ng data.
Sa panahon ng pagpapatupad ng mga micro-tagubilin, kinalkula ng susunod na generator ng address ang susunod na address ng micro-instruction at pagkatapos ay ipinadala sa rehistro ng control address upang mabasa ang susunod na micro-instruction.
Ang pagkakasunud-sunod ng mga micro-operasyon ng isang micro-program ay ginaganap ng susunod na generator ng address at kumikilos bilang tagasunud-sunod ng microprogram upang makuha ang pagkakasunud-sunod ng ad, basahin mula sa memorya ng kontrol.
Verilog Code para sa Control Unit
Ang verilog code para sa Control Unit ay ipinapakita sa ibaba.
`isama ang“ prj_definition.v ”
module 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, RF2DATA_RR
// Mga signal ng output
// Mga output para sa register file
output [`DATA_INDEX_LIMIT: 0] RF_DATA_W
output [`ADDRESS_INDEX_LIMIT: 0] RF_ADDR_W, RF_ADDR_R1, RF_ADDR_R2
output RF_READ, RF_WRITE
// Mga output para sa ALU
output [`DATA_INDEX_LIMIT: 0] ALU_OP1, ALU_OP2
output [`ALU_OPRN_INDEX_LIMIT: 0] ALU_OPRN
// Mga output para sa memorya
output [`ADDRESS_INDEX_LIMIT: 0] MEM_ADDR
output MEM_READ, MEM_WRITE
// Mga signal ng input
input [`DATA_INDEX_LIMIT: 0] RF_DATA_R1, RF_DATA_R2, ALU_RESULT
input ZERO, CLK, RST
// Inout signal
inout [`DATA_INDEX_LIMIT: 0] MEM_DATA
// Mga lambat ng estado
wire [2: 0] proc_state
// humahawak ng halaga ng counter ng programa, iniimbak ang kasalukuyang pagtuturo, magparehistro ng stack pointer
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] estado, susunod_state
PROC_SM state_machine (.STATE (proc_state), CLK (CLK) ,. RST (RST))
laging @ (posedge CLK)
magsimula
kung (RST)
estado<= RST
iba pa
estado<= next_state
magtapos
laging @ (estado)
magsimula
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
kaso (estado)
`PROC_FETCH: magsimula
next_state = `PROC_DECODE
MEM_READ = 1’b1
RF_ADDR_R1 = 1’b0 RF_ADDR_R2 = 1’b0
RF_ADDR_W = 1’b1
magtapos
`PROC_DECODE: magsimula
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
magtapos
`PROC_EXE: magsimula
next_state = `PROC_MEM
ALU_OP1 = 1’b1 ALU_OP2 = 1’b1 ALU_OPRN = 1’b1
RF_ADDR_R1 = 1’b0
magtapos
`PROC_MEM: magsimula
next_state = `PROC_WB
MEM_READ = 1’b1 MEM_WRITE = 1’b0
magtapos
`PROC_WB: magsimula
next_state = `PROC_FETCH
MEM_READ = 1’b1 MEM_WRITE = 1’b0
magtapos
pagtatapos
magtapos
endmodule
module PROC_SM (STATE, CLK, RST)
// listahan ng mga input
input CLK, RST
// listahan ng mga output
output [2: 0] STATE
// listahan ng input
input CLK, RST
// listahan ng output
output STATE
reg [2: 0] STATE
reg [1: 0] estado
reg [1: 0] susunod_state
reg PC_REG, INST_REG, SP_REF
`tukuyin ang PROC_FETCH 3'h0
`tukuyin ang PROC_DECODE 3’h1
`tukuyin ang PROC_EXE 3’h2
`tukuyin ang PROC_MEM 3’h3
`tukuyin ang PROC_WB 3’h4
// pagsisimula ng estado
inisyal
magsimula
estado = 2’bxx
next_state = `PROC_FETCH
magtapos
// reset ang paghawak ng signal
laging @ (posedge RST)
magsimula
estado = `PROC_FETCH
next_state = `PROC_FETCH
magtapos
laging @ (posedge CLK)
magsimula
estado = susunod_state
magtapos
laging @ (estado)
magsimula
kung (estado === `PROC_FETCH)
magsimula
next_state = `PROC_DECODE
print_instruction (INST_REG)
magtapos
kung (estado === `PROC_DECODE)
magsimula
next_state = `PROC_EXE
magtapos
kung (estado === `PROC_EXE)
magsimula
next_state = `PROC_MEM
print_instruction (SP_REF)
magtapos
kung (estado === `PROC_MEM)
magsimula
next_state = `PROC_WB
magtapos
kung (estado === `PROC_WB)
magsimula
next_state = `PROC_FETCH
print_instruction (PC_REG)
magtapos
magtapos
gawain sa pag-print_inscription
input [`DATA_INDEX_LIMIT: 0] inst
reg [5: 0] opcode
reg [4: 0] rs
reg [4: 0] rt
reg [4: 0] rd
reg [4: 0] shamt reg [5: 0] func reg [15: 0] agarang reg [25: 0] address
magsimula
// parse ang tagubilin
// R-type
{opcode, rs, rt, rd, shamt, func} = inst
// I-type
{opcode, rs, rt, immediate} = inst
// J-type
{opcode, address} = inst
$ sulat (“@% 6dns -> [0X% 08h]“, $ oras, inst)
kaso (opcode) // R-Type
6'h00: magsimula
kaso (pagpapaandar)
6’h20: $ magsulat (“idagdag r [% 02d], r [% 02d], r [% 02d]”, rs, rt, rd)
6’h22: $ sumulat (“sub r [% 02d], r [% 02d], r [% 02d]”, rs, rt, rd)
6’h2c: $ sumulat (“mul r [% 02d], r [% 02d], r [% 02d]”, rs, rt, rd)
6’h24: $ sumulat (“at r [% 02d], r [% 02d], r [% 02d]”, rs, rt, rd)
6’h25: $ sumulat (“o r [% 02d], r [% 02d], r [% 02d]”, rs, rt, rd)
6’h27: $ sumulat (“nor r [% 02d], r [% 02d], r [% 02d]”, rs, rt, rd)
6’h2a: $ sumulat (“slt r [% 02d], r [% 02d], r [% 02d]”, rs, rt, rd)
6’h00: $ sumulat (“sll r [% 02d],% 2d, r [% 02d]”, rs, shamt, rd)
6’h02: $ sumulat (“srl r [% 02d], 0X% 02h, r [% 02d]”, rs, shamt, rd)
6’h08: $ sumulat (“jr r [% 02d]”, rs)
default: $ sulat ('')
pagtatapos
magtapos
// I-type
6’h08: $ sumulat (“addi r [% 02d], r [% 02d], 0X% 04h”, rs, rt, agarang)
6’h1d: $ sumulat (“muli r [% 02d], r [% 02d], 0X% 04h”, rs, rt, agarang)
6’h0c: $ sumulat (“andi r [% 02d], r [% 02d], 0X% 04h”, rs, rt, agarang)
6’h0d: $ sumulat (“ori r [% 02d], r [% 02d], 0X% 04h”, rs, rt, agarang)
6’h0f: $ sumulat (“lui r [% 02d], 0X% 04h”, rt, agarang)
6’h0a: $ sumulat (“slti r [% 02d], r [% 02d], 0X% 04h”, rs, rt, agarang)
6’h04: $ sumulat (“beq r [% 02d], r [% 02d], 0X% 04h”, rs, rt, agarang)
6’h05: $ sumulat (“bne r [% 02d], r [% 02d], 0X% 04h”, rs, rt, agarang)
6’h23: $ sumulat (“lw r [% 02d], r [% 02d], 0X% 04h”, rs, rt, agarang)
6’h2b: $ sumulat (“sw r [% 02d], r [% 02d], 0X% 04h”, rs, rt, agarang)
// J-Type
6’h02: $ sumulat (“jmp 0X% 07h”, address)
6’h03: $ sumulat ('jal 0X% 07h', address)
6'h1b: $ sumulat ('push')
6'h1c: $ sumulat ('pop')
default: $ sulat ('')
pagtatapos
$ sulat (' n')
magtapos
endtask
end module
Mga FAQ
1). Ano ang gawain ng isang control unit?
Ang gawain ng control unit ay upang idirekta ang daloy ng data o mga tagubilin para sa pagpapatupad ng processor ng isang computer. Kinokontrol, pinamamahalaan at pinagsasama nito ang pangunahing memorya, ALU, mga pagrehistro, input, at output unit. Kinukuha nito ang mga tagubilin at bumubuo ng mga signal ng kontrol para sa pagpapatupad.
2). Ano ang memorya ng kontrol?
Ang memorya ng kontrol ay karaniwang RAM o ROM upang maiimbak ang address at data ng rehistro ng kontrol.
3). Ano ang control unit ng Wilkes?
Ang sunud-sunod at mga kombinasyon ng kombinasyon ng hardwired control unit ay pinalitan ng Wilkes control unit. Gumagamit ito ng isang yunit ng imbakan upang maiimbak ang mga pagkakasunud-sunod ng mga tagubilin ng isang micro-program.
4). Ano ang isang hardwired control unit?
Ang hardwired control unit ay bumubuo ng mga signal ng kontrol sa pamamagitan ng pagbabago mula sa isang estado patungo sa isa pang estado sa bawat orasan na pulso nang walang anumang pisikal na pagbabago sa circuit. Ang pagbuo ng mga signal ng control ay nakasalalay sa mga tagubilin magparehistro, decoder, at makagambala signal.
5). Ano ang memorya ng kontrol?
Ang impormasyon ng control unit o data ay pansamantala o permanenteng nakaimbak sa control memory.
Ang memorya ng kontrol ay may dalawang uri. Ang mga ito ay Random Access Memory (RAM) at Read-Only Memory (ROM).
Sa gayon, ito ay tungkol sa kahulugan, sangkap, disenyo, diagram, pagpapaandar, at mga uri ng Control Unit . Narito ang isang katanungan para sa iyo, 'Ano ang layunin ng rehistro ng control address?'
