Steuerwerk (Control Unit) erklärt: Komponenten & Design in CPUs

Das Steuerwerk ist die Hauptkomponente einer Central Processing Unit (CPU) in Computern, die die Operationen während der Programmausführung durch den Prozessor/Computer steuert. Die Hauptfunktion des Steuerwerks ist das Holen und Ausführen von Instruktionen aus dem Speicher eines Computers. Es empfängt die Eingabe-Instruktion/Information vom Benutzer und wandelt sie in Steuersignale um, die dann an die CPU zur weiteren Ausführung gegeben werden. Es ist als Teil der Von-Neumann-Architektur enthalten, entwickelt von John Neumann. Es ist verantwortlich für die Bereitstellung von Timing-Signalen und Steuersignalen und leitet die Ausführung eines Programms durch die CPU. In modernen Computern ist es als interner Teil der CPU enthalten. Dieser Artikel beschreibt vollständige Informationen über das Steuerwerk.

Was ist das Steuerwerk?

Die Komponente, die das Eingangssignal/Information/Instruktion vom Benutzer empfängt und in Steuersignale für die Ausführung in der CPU umwandelt. Es steuert und leitet den Hauptspeicher, die arithmetisch-logische Einheit (ALU), Ein- und Ausgabegeräte und ist auch verantwortlich für die Instruktionen, die an die CPU eines Computers gesendet werden. Es holt die Instruktionen aus dem Hauptspeicher eines Prozessors und sendet sie an das Prozessor-Instruktionsregister, das Registerinhalte enthält.

Das Steuerwerk wandelt die Eingabe in Steuersignale um und sendet sie an den Prozessor und leitet die Programmausführung. Die durchzuführenden Operationen werden vom Prozessor am Computer dirigiert. Hauptsächlich Central Processing Unit (CPU) und Graphical Processing Unit (GPU) benötigen ein Steuerwerk als internen Teil. Das Blockdiagramm des Steuerwerks ist oben gezeigt.

Komponenten eines Steuerwerks

Die Komponenten dieser Einheit sind Instruktionsregister, Steuersignale innerhalb der CPU, Steuersignale zu/vom Bus, Steuerbus, Eingabe-Flags und Taktsignale.

Die Komponenten des hardwired Steuerwerks sind Instruktionsregister (enthält Opcode und Adressfeld), Timing-Einheit, Steuerzustandsgenerator, Steuersignal-Generierungsmatrix und Instruktionsdecoder.
Die Komponenten des mikroprogrammierten Steuerwerks sind der nächste-Adress-Generator, ein Steueradressregister, Steuerspeicher und Steuerdatenregister.

Funktionen

Die Funktionen des Steuerwerks umfassen Folgendes.

• Es leitet den Datenfluss zwischen Prozessor und anderen Geräten.
• Es kann Instruktionen interpretieren und den Datenfluss im Prozessor steuern.
• Es generiert die Sequenz von Steuersignalen aus den empfangenen Instruktionen oder Befehlen aus dem Instruktionsregister.
• Es hat die Verantwortung, Ausführungseinheiten wie ALU, Datenpuffer und Register in der CPU eines Computers zu steuern.
• Es hat die Fähigkeit, zu holen, zu dekodieren, die Ausführung zu handhaben und Ergebnisse zu speichern.
• Es kann Daten nicht verarbeiten und speichern
• Für Datentransfer kommuniziert es mit Ein- und Ausgabegeräten und steuert alle Einheiten des Computers.

Design des Steuerwerks

Das Design kann mit zwei Typen eines Steuerwerks erfolgen, die Folgendes umfassen.

• Hardwired (hardwareverdrahtet)
• Mikroprogrammiert (single-level und two-level)

Hardwired Control Unit

Das Grunddesign eines hardwired Steuerwerks ist oben gezeigt. In diesem Typ werden die Steuersignale durch eine spezielle Hardware-Logikschaltung erzeugt, ohne Änderung der Schaltungsstruktur. In diesem Fall kann das erzeugte Signal nicht für die Ausführung im Prozessor modifiziert werden.

Die Grunddaten eines Opcodes (Operationscode einer Instruktion) werden zum Instruktionsdecoder zum Dekodieren gesendet. Der Instruktionsdecoder ist ein Satz von Decodern, um verschiedene Datentypen im Opcode zu dekodieren. Dies ergibt Ausgangssignale, die Werte aktiver Signale enthalten, die als Eingabe an den Matrixgenerator gegeben werden, um Steuersignale für die Programmausführung durch den Prozessor des Computers zu generieren.

Der Matrixgenerator liefert Zustände des Steuerwerks und die Signale aus dem Prozessor (Interrupt-Signale). Die Matrix ist als programmierbares Logikarray aufgebaut. Die vom Matrixgenerator erzeugten Steuersignale werden als Eingabe an den nächsten Generatormatrix gegeben und mit den Timing-Signalen der Timing-Einheit kombiniert, die rechteckige Muster enthalten.

Für das Holen einer neuen Instruktion wechselt das Steuerwerk in einen Initialzustand für die Ausführung der neuen Instruktion. Das Steuerwerk verbleibt im Initialzustand oder ersten Zustand, solange die Timing-Signale, Eingangssignale und Instruktionszustände eines Computers unverändert sind. Eine Zustandsänderung des Steuerwerks kann eintreten, wenn sich eines der erzeugten Signale ändert.

Wenn ein externes Signal oder Interrupt auftritt, geht das Steuerwerk in den nächsten Zustand und verarbeitet das Interrupt-Signal. Flags und Zustände werden verwendet, um die gewünschten Zustände für die Ausführung des Instruktionszyklus auszuwählen.

Im letzten Zustand holt das Steuerwerk die nächste Instruktion und sendet die Ausgabe an den Program Counter, dann an das Memory Address Register, an das Buffer Register und dann an das Instruktionsregister, um die Instruktion zu lesen. Schließlich, wenn die letzte Instruktion (die vom Steuerwerk geholt wurde) eine End-Instruktion ist, geht es in den Betriebszustand des Prozessors und wartet, bis der Benutzer das nächste Programm anweist.

Mikroprogrammiertes Steuerwerk

In diesem Typ wird der Steuerspeicher verwendet, um die Steuersignale zu speichern, die während der Programmausführung kodiert sind. Das Steuersignal wird nicht sofort erzeugt und dekodiert, weil das Mikroprogramm das Adressfeld im Steuerspeicher speichert. Der gesamte Prozess ist ein Single-Level.

Die Mikrooperationen werden für die Ausführung von Mikroinstruktionen im Programm durchgeführt. Das Blockdiagramm des mikroprogrammierten Steuerwerks ist oben gezeigt. Aus dem Diagramm wird die Adresse der Mikroinstruktion aus dem Control Memory Address Register erhalten. Alle Informationen des Steuerwerks sind permanent im Steuerspeicher, genannt ROM, gespeichert.

Die Mikroinstruktion aus dem Steuerspeicher wird vom Control Register gehalten. Da die Mikroinstruktion in Form eines Control Words (enthält binäre Steuerwerte) vorliegt, das 1 oder mehr Mikrooperationen für die Datenverarbeitung erfordert.

Während der Ausführung von Mikroinstruktionen berechnet der Next Address Generator die nächste Adresse der Mikroinstruktion und sendet sie an das Control Address Register, um die nächste Mikroinstruktion zu lesen.
Die Sequenz von Mikrooperationen eines Mikroprogramms wird vom Next Address Generator durchgeführt und fungiert als Mikroprogramm-Sequencer, um die Sequenzadresse zu erhalten, d. h. aus dem Control Memory zu lesen.

Verilog Code für das Steuerwerk

Verilog Code für Control Unit ist unten gezeigt.

`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 signals
// Outputs for 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 for ALU
output [`DATA_INDEX_LIMIT:0] ALU_OP1, ALU_OP2;
output [`ALU_OPRN_INDEX_LIMIT:0] ALU_OPRN;

// Outputs for memory
output [`ADDRESS_INDEX_LIMIT:0] MEM_ADDR;
output MEM_READ, MEM_WRITE;

// Input signals
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;

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

//holds program counter value, stores the current instruction, 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);
// list of inputs
input CLK, RST;
// list of outputs
output [2:0] STATE;

// input list
input CLK, RST;
// output list
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

// initiation of state
initial
begin
state = 2'bxx;
next_state = `PROC_FETCH;
end

// reset signal handling
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 the instruction
// 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

FAQs

1). Was ist die Aufgabe eines Steuerwerks?

Die Aufgabe des Steuerwerks ist es, den Daten- oder Instruktionsfluss für die Ausführung durch den Prozessor eines Computers zu leiten. Es steuert, verwaltet und koordiniert Hauptspeicher, ALU, Register, Ein- und Ausgabeeinheiten. Es holt Instruktionen und generiert Steuersignale für die Ausführung.

2). Was ist der Steuerspeicher?

Steuerspeicher ist meist RAM oder ROM zum Speichern der Adresse und Daten des Steuerregisters.

3). Was ist das Wilkes-Steuerwerk?

Die sequenziellen und kombinatorischen Schaltungen des hardwired Steuerwerks werden durch das Wilkes-Steuerwerk ersetzt. Es nutzt eine Speichereinheit zum Speichern der Sequenzen von Instruktionen eines Mikroprogramms.

4). Was ist ein hardwired Steuerwerk?

Das hardwired Steuerwerk erzeugt Steuersignale durch Wechsel von einem Zustand in den nächsten bei jedem Taktzyklus ohne physische Änderung der Schaltung. Die Erzeugung der Steuersignale hängt vom Instruktionsregister, Decoder und Interrupt-Signalen ab.

5). Was ist der Steuerspeicher?

Die Informationen des Steuerwerks oder Daten werden temporär oder permanent im Steuerspeicher gespeichert.
Steuerspeicher ist von zwei Typen. Sie sind Random Access Memory (RAM) und Read-Only Memory (ROM).

Damit ist dies alles über Definition, Komponenten, Design, Diagramm, Funktionen und Typen des Steuerwerks. Hier ist eine Frage für Sie: „Was ist der Zweck des Steueradressregisters?“