Was ist eine Steuereinheit:Komponenten und ihr Design

Die Steuereinheit ist die Hauptkomponente einer zentralen Verarbeitungseinheit (CPU) in Computern, die die Operationen während der Ausführung eines Programms durch den Prozessor/Computer steuern kann. Die Hauptfunktion der Steuereinheit besteht darin, Anweisungen aus dem Speicher eines Computers abzurufen und auszuführen. Es empfängt die eingegebenen Anweisungen/Informationen vom Benutzer und wandelt sie in Steuersignale um, die dann zur weiteren Ausführung an die CPU gegeben werden. Es ist als Teil der Von Neumann-Architektur enthalten, die von John Neumann entwickelt wurde. Er ist für die Bereitstellung der Zeitsteuerungssignale und Steuersignale verantwortlich und leitet die Ausführung eines Programms durch die CPU. Es ist als interner Teil der CPU in modernen Computern enthalten. Dieser Artikel beschreibt vollständige Informationen über das Steuergerät.

Was ist die Steuereinheit?

Die Komponente, die das Eingabesignal/Informationen/Anweisungen vom Benutzer empfängt und in Steuersignale für die Ausführung in der CPU umwandelt. Es steuert und steuert den Hauptspeicher, die arithmetische &logische Einheit (ALU), die Ein- und Ausgabegeräte und ist auch für die Anweisungen verantwortlich, die an die CPU eines Computers gesendet werden. Es holt die Befehle aus dem Hauptspeicher eines Prozessors und sendet sie an das Prozessorbefehlsregister, das den Registerinhalt enthält.

Die Steuereinheit wandelt die Eingabe in Steuersignale um und sendet sie dann an den Prozessor und leitet die Ausführung eines Programms. Die auszuführenden Operationen werden vom Prozessor auf dem Computer geleitet. Vor allem die Central Processing Unit (CPU) und die Graphical Processing Unit (GPU) benötigen als internen Teil eine Steuereinheit. Das Blockschaltbild der Steuereinheit ist oben dargestellt.

Komponenten einer Steuereinheit

Die Komponenten dieser Einheit sind Befehlsregister, Steuersignale innerhalb der CPU, Steuersignale zum/vom Bus, Steuerbus, Eingangsflags und Taktsignale.

Die Komponenten der Hardwired-Steuereinheit sind Befehlsregister (enthält Opcode und Adressfeld), Zeiteinheit, Steuerzustandsgenerator, Steuersignalerzeugungsmatrix und Befehlsdecoder.
Die Komponenten der mikroprogrammierten Steuereinheit sind die nächste Adresse Generator, ein Steueradreßregister, einen Steuerspeicher und ein Steuerdatenregister.

Funktionen

Die Funktionen der Steuereinheit schließen Sie Folgendes ein.

• Es leitet den Datenfluss zwischen dem Prozessor und anderen Geräten.
• Es kann die Anweisungen interpretieren und den Datenfluss im Prozessor steuern.
• Erzeugt die Folge von Steuersignalen aus den empfangenen Befehlen oder Befehlen aus dem Befehlsregister.
• Es hat die Verantwortung, die Ausführungseinheiten wie ALU, Datenpuffer und Register in der CPU eines Computers zu steuern.
• Es hat die Fähigkeit, Ergebnisse abzurufen, zu decodieren, die Ausführung zu verarbeiten und Ergebnisse zu speichern.
• Es kann die Daten nicht verarbeiten und speichern
• Um die Daten zu übertragen, kommuniziert es mit den Ein- und Ausgabegeräten und steuert alle Einheiten des Computers.

Design der Steuereinheit

Das Design kann mit zwei Typen einer Steuereinheit erfolgen die Folgendes beinhalten.

• Festverdrahtet
• Mikroprogrammiert (einstufig und zweistufig)

Festverdrahtete Steuereinheit

Der grundlegende Aufbau einer festverdrahteten Steuereinheit ist oben dargestellt. Bei diesem Typ werden die Steuersignale von einer speziellen Hardware-Logikschaltung erzeugt, ohne dass sich der Aufbau der Schaltung ändert. Dabei kann das generierte Signal für die Ausführung im Prozessor nicht modifiziert werden.

Die Basisdaten eines Opcodes (Operationscode eines Befehls wird zum Decodieren an den Befehlsdecoder gesendet. Der Befehlsdecoder ist der Satz von Decodern zum Decodieren verschiedener Datentypen im Opcode. Dies führt zu Ausgangssignalen, die Werte von aktiven Signalen enthalten die als Eingabe an den Matrixgenerator gegeben werden, um Steuersignale für die Ausführung eines Programms durch den Prozessor des Computers zu erzeugen.

Der Matrixgenerator liefert Zustände der Steuereinheit und die Signale aus dem Prozessor (Interrupt-Signale). Matrix ist als programmierbares Logikarray aufgebaut. Die vom Matrixgenerator erzeugten Steuersignale werden als Eingabe an die nächste Generatormatrix gegeben und mit den Taktsignalen der Takteinheit kombiniert, die rechteckige Muster enthält.

Zum Holen eines neuen Befehls wird die Steuereinheit zu einer Anfangsstufe für die Ausführung eines neuen Befehls. Die Steuereinheit bleibt in der Anfangsstufe oder ersten Stufe, solange die Zeitsteuerungssignale, Eingangssignale und Befehlszustände eines Computers unverändert sind. Die Zustandsänderung der Steuereinheit kann erhöht werden, wenn sich eines der erzeugten Signale ändert.

Wenn ein externes Signal oder eine Unterbrechung auftritt, geht die Steuereinheit in den nächsten Zustand und führt die Verarbeitung des Unterbrechungssignals durch. Die Flags und Zustände werden verwendet, um die gewünschten Zustände auszuwählen, um den Ausführungszyklus des Befehls auszuführen.

Im letzten Zustand holt die Steuereinheit den nächsten Befehl und sendet die Ausgabe zum Programmzähler, dann zum Speicheradreßregister, zum Pufferregister und dann zum Befehlsregister, um den Befehl zu lesen. Wenn der letzte Befehl (der von der Steuereinheit geholt wird) schließlich ein Endbefehl ist, geht er in den Betriebszustand des Prozessors und wartet, bis der Benutzer das nächste Programm anweist.

Mikroprogrammierte Steuereinheit

Bei dieser Art wird der Steuerspeicher verwendet, um die Steuersignale zu speichern, die während der Ausführung eines Programms codiert werden. Das Steuersignal wird nicht sofort erzeugt und decodiert, da das Mikroprogramm das Adressfeld im Steuerspeicher speichert. Der gesamte Prozess ist eine einzige Ebene.

Die Mikrooperationen dienen der Ausführung von Mikrobefehlen im Programm. Das Blockschaltbild der Micro-programmierten Steuereinheit ist oben dargestellt. Aus dem Diagramm wird die Adresse des Mikrobefehls aus dem Adressregister des Steuerspeichers erhalten. Alle Informationen der Steuereinheit werden dauerhaft im Speicher der Steuerung namens ROM gespeichert.

Der Mikrobefehl aus dem Steuerspeicher wird vom Steuerregister gehalten. Da der Mikrobefehl in Form eines Steuerworts vorliegt (das binäre Steuerwerte enthält), müssen für die Datenverarbeitung eine oder mehrere Mikrooperationen ausgeführt werden.

Während der Ausführung von Mikrobefehlen berechnet der nächste Adressgenerator die nächste Adresse des Mikrobefehls und sendet sie dann an das Steueradressregister, um den nächsten Mikrobefehl zu lesen.
Die Abfolge der Mikrooperationen eines Mikrobefehls -Programm wird vom nächsten Adressgenerator ausgeführt und fungiert als Mikroprogramm-Sequenzer, um die Sequenzadresse zu erhalten, dh aus dem Steuerspeicher zu lesen.

Verilog-Code für die Steuereinheit

Der Verilog-Code für die Steuereinheit wird unten angezeigt.

`include "prj_definition.v"

Modul 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, RP ALU,_REST, R A

// Ausgangssignale
// Ausgänge für Registerdatei

Ausgang [`DATA_INDEX_LIMIT:0] RF_DATA_W;
Ausgang [`ADDRESS_INDEX_LIMIT:0] RF_ADDR_W, RF_ADDR_R1, RF_ADDR_R2;
Ausgang RF_READ, RF_WRITE;

// Ausgänge für ALU
Ausgang [`DATA_INDEX_LIMIT:0] ALU_OP1, ALU_OP2;
Ausgang [`ALU_OPRN_INDEX_LIMIT:0] ALU_OPRN;

// Ausgaben für Speicher
Ausgabe [`ADDRESS_INDEX_LIMIT:0] MEM_ADDR;
Ausgabe MEM_READ, MEM_WRITE;

// Eingangssignale
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;

// Zustandsnetze
wire [2:0] proc_state;

// hält Programmzählerwert, speichert die aktuelle Anweisung, Stack-Zeigerregister

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));

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

Ende

immer @ (Zustand)
beginnen

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;

Fall( Zustand )

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

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

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

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

`PROC_WB:begin
next_state =`PROC_FETCH;
MEM_READ =1’b1; MEM_WRITE =1’b0;
Ende
Endfall

end
endmodul;

Modul PROC_SM(STATE,CLK,RST);
// Liste der Eingänge
Eingang CLK, RST;
// Liste der Ausgänge
Ausgang [2:0] STATE;

// Eingabeliste
Eingabe CLK, RST;
// Ausgabeliste
Ausgabe 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

// Zustandsinitiierung
initial
begin
state =2’bxx;
next_state =`PROC_FETCH;
Ende

// Signalbehandlung zurücksetzen
always @ (posedge RST)
begin
state =`PROC_FETCH;
next_state =`PROC_FETCH;
end
always @ ( gestellte CLK)
begin
state =next_state;
ende
immer @(state)
begin
if (state ===`PROC_FETCH)
begin
next_state =`PROC_DECODE;

print_instruction(INST_REG);
Ende

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

Ende

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

print_instruction(SP_REF);
Ende

if (state ===`PROC_MEM)
begin
nächster_state =`PROC_WB;

Ende

if (state ===`PROC_WB)
begin
nächster_state =`PROC_FETCH;

print_instruction(PC_REG);
Ende
Ende

Aufgabe print_instruction;

Eingabe [`DATA_INDEX_LIMIT:0] inst;

reg [5:0] opcode;
reg [4:0] rs;
reg [4:0] rt;
reg [4:0] rd;
reg [ 4:0] schein; reg [5:0] Funktion; reg [15:0] sofort; reg [25:0] Adresse;

beginnen

// die Anweisung analysieren
// R-Typ

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

// I-Typ
{opcode, rs, rt, unmittelbar } =inst;
// J-Typ
{opcode, Adresse} =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(“und r[%02d], r[%02d], r[%02d];”, rs , rt, rd);
6'h25:$write(“oder 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);
Standard:$write(““);
endcase
end

// I-Typ

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

// J-Typ

6'h02 :$write("jmp 0X%07h;", ​​Adresse);
6'h03 :$write("jal 0X%07h;", ​​Adresse);
6'h1b :$write ("push;");
6'h1c :$write("pop;");
default:$write("");
endcase
$write (" \n”);
Ende
Endtask
Ende des Moduls;

Häufig gestellte Fragen

1). Welche Aufgaben hat ein Steuergerät?

Die Aufgabe der Steuereinheit besteht darin, den Datenfluss oder die Anweisungen zur Ausführung durch den Prozessor eines Computers zu lenken. Es steuert, verwaltet und koordiniert Hauptspeicher, ALU, Register, Ein- und Ausgabeeinheiten. Es holt die Anweisungen ab und generiert Steuersignale für die Ausführung.

2). Was ist der Kontrollspeicher?

Der Steuerspeicher ist normalerweise ein RAM oder ROM, um die Adresse und Daten des Steuerregisters zu speichern.

3). Was ist das Wilkes-Steuergerät?

Die Folge- und Kombinationsschaltungen des festverdrahteten Steuergeräts werden durch das Wilkes-Steuergerät ersetzt. Es verwendet eine Speichereinheit, um die Befehlsfolgen eines Mikroprogramms zu speichern.

4). Was ist eine festverdrahtete Steuereinheit?

Die festverdrahtete Steuereinheit erzeugt die Steuersignale, indem sie bei jedem Taktimpuls von einem Zustand in einen anderen Zustand wechselt, ohne dass sich die Schaltung physikalisch ändert. Die Erzeugung von Steuersignalen hängt von Befehlsregister, Decoder und Interrupt-Signalen ab.

5). Was ist der Kontrollspeicher?

Die Informationen der Steuereinheit oder Daten werden temporär oder dauerhaft im Steuerspeicher gespeichert.
Der Steuerspeicher ist von zwei Arten. Sie sind Random Access Memory (RAM) und Read-Only Memory (ROM).

Es geht also um Definition, Komponenten, Aufbau, Schema, Funktionen und Typen von Control Units. Hier ist eine Frage an Sie:„Was ist der Zweck des Steueradressregisters?“