Wat is Control Unit:Components &Its Design

De besturingseenheid is het hoofdbestanddeel van een centrale verwerkingseenheid (CPU) in computers die de bewerkingen tijdens de uitvoering van een programma door de processor/computer kan sturen. De belangrijkste functie van de besturingseenheid is het ophalen en uitvoeren van instructies uit het geheugen van een computer. Het ontvangt de invoerinstructie/informatie van de gebruiker en zet deze om in besturingssignalen, die vervolgens aan de CPU worden gegeven voor verdere uitvoering. Het is opgenomen als onderdeel van de Von Neumann-architectuur, ontwikkeld door John Neumann. Het is verantwoordelijk voor het leveren van de timingsignalen en besturingssignalen en stuurt de uitvoering van een programma door de CPU. Het is opgenomen als een intern onderdeel van de CPU in moderne computers. Dit artikel beschrijft volledige informatie over de besturingseenheid.

Wat is de regeleenheid?

De component die het ingangssignaal/informatie/instructie van de gebruiker ontvangt en omzet in stuursignalen voor uitvoering in de CPU. Het bestuurt en stuurt het hoofdgeheugen, rekenkundige en logische eenheid (ALU), invoer- en uitvoerapparaten, en is ook verantwoordelijk voor de instructies die naar de CPU van een computer worden gestuurd. Het haalt de instructies op uit het hoofdgeheugen van een processor en wordt verzonden naar het processorinstructieregister, dat de inhoud van het register bevat.

De besturingseenheid zet de invoer om in besturingssignalen en wordt vervolgens naar de processor gestuurd en stuurt de uitvoering van een programma aan. De bewerkingen die moeten worden uitgevoerd, worden aangestuurd door de processor op de computer. Voornamelijk Central Processing Unit (CPU) en Graphical Processing Unit (GPU) vereisen een besturingseenheid als intern onderdeel. Het blokschema van de besturingseenheid is hierboven weergegeven.

Onderdelen van een regeleenheid

De componenten van dit apparaat zijn instructieregisters, besturingssignalen binnen de CPU, besturingssignalen van/naar de bus, besturingsbus, ingangsvlaggen en kloksignalen.

De componenten van de bedrade besturingseenheid zijn instructieregister (bevat opcode- en adresveld), timingeenheid, besturingsstatusgenerator, matrix voor het genereren van besturingssignalen en instructiedecoder.
De componenten van de micro-geprogrammeerde besturingseenheid zijn het volgende adres generator, een stuuradresregister, een stuurgeheugen en een stuurgegevensregister.

Functies

De functies van de besturingseenheid omvatten het volgende.

• Het stuurt de gegevensstroom tussen de processor en andere apparaten.
• Het kan de instructies interpreteren en de gegevensstroom in de processor regelen.
• Het genereert de reeks besturingssignalen uit de ontvangen instructies of commando's uit het instructieregister.
• Het heeft de verantwoordelijkheid om de uitvoeringseenheden zoals ALU, gegevensbuffers en registers in de CPU van een computer te controleren.
• Het heeft de mogelijkheid om de resultaten op te halen, te decoderen, af te handelen en op te slaan.
• Het kan de gegevens niet verwerken en opslaan
• Om de gegevens over te dragen, communiceert het met de invoer- en uitvoerapparaten en bestuurt het alle eenheden van de computer.

Ontwerp van besturingseenheid

Het ontwerp hiervan kan worden gedaan met behulp van twee types van een besturingseenheid waaronder het volgende.

• Hardwire gebaseerd
• Gebaseerd op microprogrammering (één niveau en twee niveaus)

Hardbedrade besturingseenheid

Het basisontwerp van een bedrade besturingseenheid is hierboven weergegeven. Bij dit type worden de stuursignalen gegenereerd door een speciale hardwarematige logische schakeling zonder enige verandering in de structuur van de schakeling. Hierbij kan het gegenereerde signaal niet worden aangepast voor uitvoering in de processor.

De basisgegevens van een opcode (bewerkingscode van een instructie wordt naar de instructiedecoder gestuurd voor decodering. De instructiedecoder is de set decoders om verschillende soorten gegevens in de opcode te decoderen. Dit resulteert in uitgangssignalen die waarden van actieve signalen bevatten die als input aan de matrixgenerator worden gegeven om stuursignalen te genereren voor de uitvoering van een programma door de processor van de computer.

De matrixgenerator levert de toestanden van de regeleenheid en de signalen van de processor (interruptsignalen). Matrix is ​​gebouwd als de programmeerbare logische array. De stuursignalen die door de matrixgenerator worden gegenereerd, worden gegeven als invoer voor de volgende generatormatrix en worden gecombineerd met de timingsignalen van de timingeenheid die rechthoekige patronen bevat.

Voor het ophalen van een nieuwe instructie verandert de besturingseenheid in een beginfase voor het uitvoeren van een nieuwe instructie. De besturingseenheid blijft in de beginfase of eerste fase zolang de timingsignalen, ingangssignalen en instructietoestanden van een computer ongewijzigd blijven. De verandering in de status van de besturingseenheid kan worden verhoogd als er een verandering is in een van de gegenereerde signalen.

Wanneer een extern signaal of een onderbreking optreedt, gaat de besturingseenheid naar de volgende toestand en voert de verwerking van het onderbrekingssignaal uit. De vlaggen en toestanden worden gebruikt om de gewenste toestanden te selecteren om de instructiecyclus uit te voeren.

In de laatste toestand haalt de besturingseenheid de volgende instructie op en stuurt de uitvoer naar de programmateller, vervolgens naar het geheugenadresregister, naar het bufferregister en vervolgens naar het instructieregister om de instructie te lezen. Ten slotte, als de laatste instructie (die wordt opgehaald door de besturingseenheid) een eindinstructie is, gaat deze naar de bedrijfsstatus van de processor en wacht tot de gebruiker het volgende programma aanstuurt.

Micro-geprogrammeerde regeleenheid

In dit type wordt het besturingsgeheugen gebruikt om de besturingssignalen op te slaan die tijdens de uitvoering van een programma worden gecodeerd. Het stuursignaal wordt niet onmiddellijk gegenereerd en gedecodeerd omdat het microprogramma het adresveld opslaat in het stuurgeheugen. Het hele proces is een enkel niveau.

De micro-operaties worden gedaan voor het uitvoeren van micro-instructies in het programma. Het blokschema van de Micro-geprogrammeerde besturingseenheid is hierboven weergegeven. Uit het diagram wordt het adres van de micro-instructie verkregen uit het adresregister van het stuurgeheugen. Alle informatie van de besturingseenheid wordt permanent opgeslagen in het besturingsgeheugen genaamd ROM.

De micro-instructie uit het stuurgeheugen wordt vastgehouden door het stuurregister. Aangezien de micro-instructie de vorm heeft van een stuurwoord (bevat binaire stuurwaarden) moeten er 1 of meer micro-operaties worden uitgevoerd voor de gegevensverwerking.

Tijdens de uitvoering van micro-instructies berekent de volgende adresgenerator het volgende adres van de micro-instructie en stuurt het vervolgens naar het stuuradresregister om de volgende micro-instructie te lezen.
De volgorde van micro-operaties van een micro -programma wordt uitgevoerd door de volgende adresgenerator en fungeert als microprogramma-sequencer om het sequentie-adres te krijgen, dat wil zeggen, gelezen uit het besturingsgeheugen.

Verilog-code voor de regeleenheid

De Verilog-code voor de regeleenheid wordt hieronder weergegeven.

`inclusief "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_READ, MEM_READ, MEM_WRITER1, RF_DATA_DATA_DATA)

// Uitgangssignalen
// Uitgangen voor registerbestand

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;

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

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

// Invoersignalen
invoer [`DATA_INDEX_LIMIT:0] RF_DATA_R1, RF_DATA_R2, ALU_RESULT;
invoer ZERO, CLK, RST;

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

// Staatsnetten
wire [2:0] proc_state;

// houdt de programmatellerwaarde vast, slaat de huidige instructie op, stapelaanwijzerregister

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] staat, volgende_staat;

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

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

einde

altijd @ (staat)
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;

geval (staat )

`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;
einde

`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;
einde

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

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

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

end
eindmodule;

module PROC_SM(STATE,CLK,RST);
// lijst met ingangen
ingang CLK, RST;
// lijst met uitgangen
uitgang [2:0] STATE;

// invoerlijst
invoer CLK, RST;
// uitvoerlijst
uitvoer STATE;

reg [2:0] STAAT;
reg [1:0] staat;
reg [1:0] volgende_staat;

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 staat
initieel
begin
state =2'bxx;
next_state =`PROC_FETCH;
end

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

print_instruction(INST_REG);
einde

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

einde

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

print_instruction(SP_REF);
einde

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

einde

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

print_instruction(PC_REG);
end
end

taak print_instruction;

invoer [`DATA_INDEX_LIMIT:0] inst;

reg [5:0] opcode;
reg [4:0] rs;
reg [4:0] rt;
reg [4:0] rd;
reg [ 4:0] schijn; reg [5:0] functie; reg [15:0] onmiddellijk; reg [25:0] adres;

begin

// ontleden de instructie
// R-type

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

// I-type
{opcode, rs, rt, onmiddellijk } =inst;
// J-type
{opcode, adres} =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(“of 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);
standaard:$write(“”);
endcase
end

// Ik typ

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

// J-type

6'h02:$write(“jmp 0X%07h;”, adres);
6'h03:$write(“jal 0X%07h;”, adres);
6'h1b:$write (“push;”);
6'h1c :$write(“pop;”);
standaard:$write(“”);
endcase
$write (“ \n”);
end
eindtaak
eindmodule;

Veelgestelde vragen

1). Wat is het werk van een regeleenheid?

Het werk van de besturingseenheid is om de stroom van gegevens of instructies te sturen voor de uitvoering door de processor van een computer. Het bestuurt, beheert en coördineert het hoofdgeheugen, ALU, registers, invoer- en uitvoereenheden. Het haalt de instructies op en genereert stuursignalen voor de uitvoering.

2). Wat is het controlegeheugen?

Het besturingsgeheugen is meestal RAM of ROM om het adres en de gegevens van het besturingsregister op te slaan.

3). Wat is de Wilkes-regeleenheid?

De sequentiële en combinatorische circuits van de bedrade besturingseenheid worden vervangen door de Wilkes-besturingseenheid. Het gebruikt een opslageenheid om de volgorde van instructies van een microprogramma op te slaan.

4). Wat is een bedrade bedieningseenheid?

De bedrade besturingseenheid genereert de besturingssignalen door in elke klokpuls van de ene toestand naar de andere te gaan zonder enige fysieke verandering in het circuit. Het genereren van stuursignalen is afhankelijk van instructieregister, decoder en onderbrekingssignalen.

5). Wat is het besturingsgeheugen?

De informatie van de regeleenheid of gegevens worden tijdelijk of permanent opgeslagen in het regelgeheugen.
Er zijn twee soorten regelgeheugen. Dit zijn Random Access Memory (RAM) en Read-Only Memory (ROM).

Dit gaat dus allemaal over de definitie, componenten, ontwerp, diagram, functies en soorten regeleenheden. Hier is een vraag voor u:"Wat is het doel van het controleadresregister?"