Control Unit Uitgelegd: Componenten & Ontwerp in CPU's

De control unit is het hoofdcomponent van een centrale verwerkingseenheid (CPU) in computers die de operaties kan sturen tijdens de uitvoering van een programma door de processor/computer. De hoofdfunctie van de control unit is om instructies uit het geheugen van een computer op te halen en uit te voeren. Het ontvangt de invoer instructie/informatie van de gebruiker en zet het om in controle signalen, die vervolgens aan de CPU gegeven worden voor verdere uitvoering. Het is opgenomen als onderdeel van Von Neumann architectuur ontwikkeld door John Neumann. Het is verantwoordelijk voor het leveren van timing signalen, en controle signalen en stuurt de uitvoering van een programma door de CPU. Het is opgenomen als een intern deel van de CPU in moderne computers. Dit artikel beschrijft complete informatie over de control unit.

Wat Is De Control Unit?

Het component dat het invoer signaal/informatie/instructie van de gebruiker ontvangt en omzet in controle signalen voor de uitvoering in de CPU. Het controleert en stuurt het hoofgeheugen, reken- & logische eenheid (ALU), invoer- en uitvoerapparaten, en is ook verantwoordelijk voor de instructies die naar de CPU van een computer gestuurd worden. Het haalt de instructies op uit het hoofgeheugen van een processor en stuurt ze naar het processor instructieregister, wat registerinhoud bevat.

De control unit zet de invoer om in controle signalen en stuurt deze dan naar de processor en stuurt de uitvoering van een programma. De operaties die uitgevoerd moeten worden worden gestuurd door de processor op de computer. Vooral Centrale Verwerkingseenheid (CPU) en Grafische Verwerkingseenheid (GPU) vereisen een control unit als intern deel. Het blokdiagram van de control unit is hierboven getoond.

Componenten van een Control Unit

De componenten van deze eenheid zijn instructieregisters, controle signalen binnen de CPU, controle signalen naar/van de bus, controlebus, invoer vlaggen, en kloksignalen.

De componenten van de Hardwired control unit zijn instructieregister (bevat opcode en adresveld), timing eenheid, controle staat generator, controle signaal generatie matrix, en instructie decoder.
De componenten van de Micro programmed control unit zijn de next address generator, een control address register, control memory, en control data register.

Functies

De functies van de control unit omvatten het volgende.

• Het stuurt de datasstromen tussen de processor en andere apparaten.
• Het kan instructies interpreteren en controleert de datasstroom in de processor.
• Het genereert de reeks controle signalen van de ontvangen instructies of commando's uit het instructieregister.
• Het heeft de verantwoordelijkheid om de uitvoeringseenheden te controleren zoals ALU, databuffers, en registers in de CPU van een computer.
• Het heeft de capaciteit om op te halen, te decoderen, de uitvoering af te handelen, en resultaten op te slaan.
• Het kan geen data verwerken en opslaan
• Om data over te dragen, communiceert het met de invoer- en uitvoerapparaten en controleert het alle eenheden van de computer.

Ontwerp van Control Unit

Het ontwerp van deze kan gedaan worden met twee typen van een control unit wat het volgende omvat.

• Hardwired gebaseerd
• Microgeprogrammeerd gebaseerd(een-niveau en twee-niveau)

Hardwired Control Unit

Het basisontewerp van een hardwired control unit is hierboven getoond. In dit type worden de controle signalen gegenereerd door een speciale hardware logica schakeling zonder enige verandering in de structuur van de schakeling. In dit kan het gegenereerde signaal niet gewijzigd worden voor uitvoering in de processor.

De basisdata van een opcode (operatiecode van een instructie wordt gestuurd naar de instructie decoder voor decodering. De instructie decoder is de set van decoders om verschillende typen data in de opcode te decoderen. Dit resulteert in uitgangssignalen die waarden van actieve signalen bevatten die als invoer gegeven worden aan de matrix generator om controle signalen te genereren voor de uitvoering van een programma door de processor van de computer.

De matrix generator levert staten van controle eenheid en de signalen uit van de processor (interrupt signalen). Matrix is gebouwd als de programmeerbare logische array. De controle signalen gegenereerd door de matrix generator worden gegeven als invoer aan de volgende generator matrix en gecombineerd met de timing signalen van de timing eenheid die rechthoekige patronen bevat.

Voor het ophalen van een nieuwe instructie, gaat de control unit in een initiële fase voor de uitvoering van een nieuwe instructie. De control unit blijft in de initiële fase of eerste fase zolang de timing signalen, invoer signalen, en staten van instructie van een computer onveranderd zijn. De verandering in de staat van de control unit kan geopperd worden als er enige verandering in een van de gegenereerde signalen is.

Wanneer een extern signaal of interrupt optreedt, gaat de control unit naar de volgende staat en voert de verwerking van het interrupt signaal uit. De vlaggen en staten worden gebruikt om de gewenste staten te selecteren om de uitvoercyclus van de instructie uit te voeren.

In de laatste staat haalt de control unit de volgende instructie op en stuurt de uitgang naar de programmateller, dan naar het geheugenenadresregister, naar het bufferregister, en dan naar het instructieregister om de instructie te lezen. Ten slotte, als de laatste instructie (die opgehaald wordt door de control unit) een eindinstructie is, dan gaat het naar de operationele staat van de processor en wacht tot de gebruiker het volgende programma stuurt.

Micro Geprogrammeerde Control Unit

In dit type wordt de control store gebruikt om de controle signalen op te slaan die gecodeerd zijn tijdens de uitvoering van een programma. Het controle signaal wordt niet direct gegenereerd en gedecodeerd omdat het microprogramma adresveld in de control store opslaat. Het hele proces is een enkel niveau.

De micro-operaties worden gedaan voor de uitvoering van micro-instructies in het programma. Het blokdiagram van de Micro geprogrammeerde control unit is hierboven getoond. Uit het diagram, wordt het adres van de micro-instructie verkregen uit het control memory address register. Alle info van de control unit is permanent opgeslagen in het control memory genaamd ROM.

De micro-instructie uit het control memory wordt vastgehouden door het control register. Aangezien de micro-instructie in de vorm is van een control word (bevat binaire controle waarden) die 1 of meer micro-operaties vereist om uitgevoerd te worden voor de dataverwerking.

Tijdens de uitvoering van micro-instructies, berekent de next address generator het volgende adres van de micro-instructie en stuurt dit naar het control address register om de volgende micro-instructie te lezen.
De reeks micro-operaties van een micro-programma wordt uitgevoerd door de next address generator en fungeert als microprogramma sequencer om het sequentieadres te krijgen, d.w.z., gelezen uit het control memory.

Verilog Code voor de Control Unit

Verilog code voor Control Unit wordt hieronder getoond.

`include “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, RF_DATA_R1, RF_DATA_R2, ALU_RESULT, ZERO, CLK, RST)

// Output signalen
// Outputs voor 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;

// Outputs voor ALU
output [`DATA_INDEX_LIMIT:0] ALU_OP1, ALU_OP2;
output [`ALU_OPRN_INDEX_LIMIT:0] ALU_OPRN;

// Outputs voor geheugen
output [`ADDRESS_INDEX_LIMIT:0] MEM_ADDR;
output MEM_READ, MEM_WRITE;

// Input signalen
input [`DATA_INDEX_LIMIT:0] RF_DATA_R1, RF_DATA_R2, ALU_RESULT;
input ZERO, CLK, RST;

// Inout signaal
inout [`DATA_INDEX_LIMIT:0] MEM_DATA;

// State nets
wire [2:0] proc_state;

//houdt programmateller waarde, slaat huidige instructie op, stack pointer register

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] state, next_state;

PROC_SM state_machine(.STATE(proc_state),.CLK(CLK),.RST(RST));

always @ (posedge CLK)
begin
if (RST)
state <= RST;
else
state <= next_state;

end

always @ (state)
begin

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;

case( state )

`PROC_FETCH : begin
next_state = `PROC_DECODE;
MEM_READ = 1’b1;
RF_ADDR_R1 = 1’b0; RF_ADDR_R2 = 1’b0;
RF_ADDR_W = 1’b1;
end

`PROC_DECODE : begin
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;
end

`PROC_EXE : begin
next_state = `PROC_MEM;
ALU_OP1 = 1’b1; ALU_OP2 = 1’b1; ALU_OPRN = 1’b1;
RF_ADDR_R1 = 1’b0;
end

`PROC_MEM: begin
next_state = `PROC_WB;
MEM_READ = 1’b1; MEM_WRITE = 1’b0;
end

`PROC_WB: begin
next_state = `PROC_FETCH;
MEM_READ = 1’b1; MEM_WRITE = 1’b0;
end
endcase

end
endmodule;

module PROC_SM(STATE,CLK,RST);
// lijst van inputs
input CLK, RST;
// lijst van outputs
output [2:0] STATE;

// input lijst
input CLK, RST;
// output lijst
output STATE;

reg [2:0] STATE;
reg [1:0] state;
reg [1:0] next_state;

reg PC_REG, INST_REG, SP_REF;

`define PROC_FETCH 3’h0
`define PROC_DECODE 3’h1
`define PROC_EXE 3’h2
`define PROC_MEM 3’h3
`define PROC_WB 3’h4

// initiatie van state
initial
begin
state = 2’bxx;
next_state = `PROC_FETCH;
end

// reset signaal afhandeling
always @ (posedge RST)
begin
state = `PROC_FETCH;
next_state = `PROC_FETCH;
end
always @ (posedge CLK)
begin
state = next_state;
end
always @(state)
begin
if (state === `PROC_FETCH)
begin
next_state = `PROC_DECODE;

print_instruction(INST_REG);
end

if (state === `PROC_DECODE)
begin
next_state = `PROC_EXE;

end

if (state === `PROC_EXE)
begin
next_state = `PROC_MEM;

print_instruction(SP_REF);
end

if (state === `PROC_MEM)
begin
next_state = `PROC_WB;

end

if (state === `PROC_WB)
begin
next_state = `PROC_FETCH;

print_instruction(PC_REG);
end
end

task print_instruction;

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] funct; reg [15:0] immediate; reg [25:0] address;

begin

// parse de instructie
// R-type

{opcode, rs, rt, rd, shamt, funct} = inst;

// I-type
{opcode, rs, rt, immediate } = inst;
// J-type
{opcode, address} = inst;
$write(“@ %6dns -> [0X%08h] “, $time, inst);
case(opcode) // R-Type
6’h00 : begin
case(funct)

6’h20: $write(“add r[%02d], r[%02d], r[%02d];”, rs, rt, rd);
6’h22: $write(“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: $write(“and r[%02d], r[%02d], r[%02d];”, rs, rt, rd);
6’h25: $write(“or r[%02d], r[%02d], r[%02d];”, rs, rt, rd);
6’h27: $write(“nor 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);
default: $write(“”);
endcase
end

// I-type

6’h08 : $write(“addi r[%02d], r[%02d], 0X%04h;”, rs, rt, immediate);
6’h1d : $write(“muli r[%02d], r[%02d], 0X%04h;”, rs, rt, immediate);
6’h0c : $write(“andi r[%02d], r[%02d], 0X%04h;”, rs, rt, immediate);
6’h0d : $write(“ori r[%02d], r[%02d], 0X%04h;”, rs, rt, immediate);
6’h0f : $write(“lui r[%02d], 0X%04h;”, rt, immediate);
6’h0a : $write(“slti r[%02d], r[%02d], 0X%04h;”, rs, rt, immediate);
6’h04 : $write(“beq r[%02d], r[%02d], 0X%04h;”, rs, rt, immediate);
6’h05 : $write(“bne r[%02d], r[%02d], 0X%04h;”, rs, rt, immediate);
6’h23 : $write(“lw r[%02d], r[%02d], 0X%04h;”, rs, rt, immediate);
6’h2b : $write(“sw r[%02d], r[%02d], 0X%04h;”, rs, rt, immediate);

// J-Type

6’h02 : $write(“jmp 0X%07h;”, address);
6’h03 : $write(“jal 0X%07h;”, address);
6’h1b : $write(“push;”);
6’h1c : $write(“pop;”);
default: $write(“”);
endcase
$write (“\n”);
end
endtask
end module;

Veelgestelde Vragen

1). Wat is het werk van een control unit?

Het werk van de control unit is om de stroom van data of instructies te sturen voor de uitvoering door de processor van een computer. Het controleert, beheert en coördineert hoofgeheugen, ALU, registers, invoer, en uitvoer eenheden. Het haalt de instructies op en genereert controle signalen voor de uitvoering.

2). Wat is het control memory?

Control memory is meestal RAM of ROM om het adres en de data van het control register op te slaan.

3). Wat is de Wilkes control unit?

De sequentiële en combinatorische schakelingen van de hardwired control unit worden vervangen door de Wilkes control unit. Het gebruikt een opslageenheid om de reeksen van instructies van een micro-programma op te slaan.

4). Wat is een hardwired control unit?

De hardwired control unit genereert de controle signalen door te veranderen van de ene staat naar de andere staat in elke klokpuls zonder enige fysieke verandering in de schakeling. De generatie van controle signalen hangt af van instructies register, decoder, en interrupt signalen.

5). Wat is het control memory?

De informatie van de control unit of data wordt tijdelijk of permanent opgeslagen in het control memory.
Control memory is van twee typen. Zij zijn Random Access Memory(RAM) en Read-Only Memory(ROM).

Dit is alles over de definitie, componenten, ontwerp, diagram, functies, en typen van Control Unit. Hier is een vraag voor u, “Wat is het doel van het control address register?”