Ce este unitatea de control: componente și designul său

Încercați Instrumentul Nostru Pentru Eliminarea Problemelor





Unitatea de control este componenta principală a unei unități centrale de procesare (CPU) în computere care poate direcționa operațiunile în timpul executării unui program prin procesorul /calculator. Funcția principală a unității de control este de a prelua și executa instrucțiuni din memoria unui computer. Acesta primește instrucțiunile / informațiile de intrare de la utilizator și le convertește în semnale de control , care sunt apoi date CPU-ului pentru o execuție ulterioară. Este inclus ca parte a arhitecturii Von Neumann dezvoltată de John Neumann. Este responsabil pentru furnizarea semnalelor de sincronizare și a semnalelor de control și direcționează executarea unui program de către CPU. Este inclus ca parte internă a procesorului în computerele moderne. Acest articol descrie informații complete despre unitatea de control.

Ce este unitatea de control?

Componenta care primește semnalul / informațiile / instrucțiunile de intrare de la utilizator și se transformă în semnale de control pentru execuția în CPU. Controlează și direcționează memoria principală, unitatea aritmetică și logică (ALU), dispozitivele de intrare și ieșire și, de asemenea, este responsabil pentru instrucțiunile trimise către CPU-ul unui computer. Prinde instrucțiunile din memoria principala unui procesor și trimis la registrul de instrucțiuni al procesorului, care conține conținutul registrului.




Diagrama blocului unității de control

Diagrama blocului unității de control

Unitatea de control convertește intrarea în semnale de control și apoi este trimis procesorului și direcționează execuția unui program. Operațiunile care trebuie efectuate sunt dirijate de procesor pe computer. În principal Unitatea Centrală de Procesare (CPU) și Unitate de procesare grafică (GPU) necesită o unitate de control ca parte internă. Schema bloc a unității de comandă este prezentată mai sus.



Componentele unei unități de control

Componentele acestei unități sunt instrucțiuni registre , semnale de control din CPU, semnale de control către / de la magistrală, magistrală de control, semnalizatoare de intrare și semnale de ceas

Componentele unității de control cablate sunt registrul de instrucțiuni (conține câmpul opcode și adresa), unitatea de sincronizare, starea de control generator , controlul matricei de generare a semnalului și decodor de instrucțiuni.
Componentele unității de control micro programate sunt următorul generator de adrese, un registru de adrese de control, memorie de control și registru de date de control.

Funcții

funcțiile unității de comandă include următoarele.


  • Direcționează fluxul de secvențe de date între procesor și alte dispozitive.
  • Poate interpreta instrucțiunile și poate controla fluxul de date în procesor.
  • Generează secvența semnalelor de control din instrucțiunile primite sau din comenzile din registrul de instrucțiuni.
  • Are responsabilitatea de a controla unitățile de execuție precum ALU, tampoane de date și înregistrări în CPU-ul unui computer.
  • Are capacitatea de a prelua, decoda, gestiona execuția și stoca rezultatele.
  • Nu poate procesa și stoca datele
  • Pentru a transfera datele, acesta comunică cu dispozitivele de intrare și ieșire și controlează toate unitățile computerului.

Proiectarea unității de control

Proiectarea acestui lucru se poate face folosind două tipurile unei unități de control care includ următoarele.

  • Bazat pe hardwire
  • Bazat pe microprogramare (cu un singur nivel și cu două niveluri)

Unitate de control prin cablu

Proiectarea de bază a unei unități de control cablate este prezentată mai sus. În acest tip, semnalele de control sunt generate de un hardware special circuit logic fără nicio modificare a structurii circuitului. În acest sens, semnalul generat nu poate fi modificat pentru a fi executat în procesor.

Datele de bază ale unui cod opțional (codul de funcționare al unei instrucțiuni este trimis la decodorul de instrucțiuni pentru decodare. Instrucțiunea decodor este setul de decodoare pentru a decoda diferite tipuri de date din codul opțional. Acest lucru are ca rezultat semnale de ieșire care conțin valori ale semnalelor active care sunt date ca intrare în generatorul de matrice pentru a genera semnale de control pentru executarea unui program de către procesorul computerului.

Unitate de control bazată pe cablu

Unitate de control bazată pe cablu

Generatorul de matrice furnizează stările unității de control și semnalele de la procesor (semnale de întrerupere). Matrix este construit ca matrice logică programabilă . Semnalele de control generate de generatorul de matrice sunt date ca intrare la următoarea matrice a generatorului și se combină cu semnalele de sincronizare ale unității de sincronizare care conține modele dreptunghiulare.

Pentru preluarea unei noi instrucțiuni, unitatea de control se transformă într-o etapă inițială pentru executarea unei instrucțiuni noi. Unitatea de control rămâne în etapa inițială sau prima etapă atâta timp cât semnalele de sincronizare, semnalele de intrare și stările de instruire ale unui computer sunt neschimbate. Schimbarea stării unității de control poate fi ridicată dacă există vreo modificare în oricare dintre semnalele generate.

Când apare un semnal extern sau întrerupere, unitatea de control trece la starea următoare și efectuează procesarea semnalului de întrerupere. Steagurile și stările sunt utilizate pentru a selecta stările dorite pentru a efectua ciclul de execuție al instrucțiunii.

În ultima stare, unitatea de control preia următoarea instrucțiune și trimite ieșirea la contorul de programe, apoi la registrul de adrese de memorie, la registrul tampon și apoi la registrul de instrucțiuni pentru a citi instrucțiunea. În cele din urmă, dacă ultima instrucțiune (care este preluată de unitatea de control) este instrucțiune finală, atunci trece la starea de funcționare a procesorului și așteaptă până când utilizatorul direcționează următorul program.

Unitate de control micro programată

În acest tip, depozitul de control este utilizat pentru a stoca semnalele de control care sunt codificate în timpul executării unui program. Semnalul de control nu este generat imediat și decodificat deoarece microprogramul stochează câmpul de adrese din magazinul de control. Întregul proces este un singur nivel.

Micro-operațiunile se fac pentru executarea microinstrucțiunilor din program. Schema bloc a unității de control micro programate este prezentată mai sus. Din diagramă, adresa microinstrucțiunii este obținută din registrul de adrese de memorie de control. Toate informațiile unității de control sunt stocate permanent în memoria de control numită ROM.

Unitate de control pe bază de microprogramare

Unitate de control pe bază de microprogramare

Microinstrucțiunile din memoria de control sunt deținute de registrul de control. Deoarece microinstrucțiunea este sub forma unui cuvânt de control (conține valori de control binar) care necesită 1 sau mai multe micro-operații pentru a fi efectuate pentru procesarea datelor.

În timpul executării microinstrucțiunilor, următorul generator de adrese a calculat următoarea adresă a microinstrucțiunii și apoi trimite la registrul de adrese de control pentru a citi următoarea microinstrucțiune.
Secvența de micro-operațiuni a unui micro-program este efectuată de următorul generator de adrese și acționează ca un secvențiator de microprogramă pentru a obține adresa de secvență, adică citită din memoria de control.

Codul Verilog pentru unitatea de control

Codul Verilog pentru unitatea de control este prezentat mai jos.

`include„ prj_definition.v ”

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

// Semnale de ieșire
// Ieșiri pentru fișierul de înregistrare

ieșire [`DATA_INDEX_LIMIT: 0] RF_DATA_W
ieșire [`ADDRESS_INDEX_LIMIT: 0] RF_ADDR_W, RF_ADDR_R1, RF_ADDR_R2
ieșire RF_READ, RF_WRITE

// Ieșiri pentru ALU
ieșire [`DATA_INDEX_LIMIT: 0] ALU_OP1, ALU_OP2
ieșire [`ALU_OPRN_INDEX_LIMIT: 0] ALU_OPRN

// Ieșiri pentru memorie
ieșire [`ADDRESS_INDEX_LIMIT: 0] MEM_ADDR
ieșire MEM_READ, MEM_WRITE

// Semnalele de intrare
input [`DATA_INDEX_LIMIT: 0] RF_DATA_R1, RF_DATA_R2, ALU_RESULT
intrare ZERO, CLK, RST

// Semnal de intrare
inout [`DATA_INDEX_LIMIT: 0] MEM_DATA

// Declarați plasele
wire [2: 0] proc_state

// deține valoarea contorului de program, stochează instrucțiunea curentă, stochează registrul indicatorului

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

mereu @ (posedge CLK)
începe
dacă (RST)
stat<= RST
altceva
stat<= next_state

Sfârșit

mereu @ (stat)
începe

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

caz (stare)

`PROC_FETCH: începe
next_state = `PROC_DECODE
MEM_READ = 1’b1
RF_ADDR_R1 = 1’b0 RF_ADDR_R2 = 1’b0
RF_ADDR_W = 1’b1
Sfârșit

`PROC_DECODE: începe
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
Sfârșit

`PROC_EXE: începe
next_state = `PROC_MEM
ALU_OP1 = 1’b1 ALU_OP2 = 1’b1 ALU_OPRN = 1’b1
RF_ADDR_R1 = 1’b0
Sfârșit

`PROC_MEM: începe
next_state = `PROC_WB
MEM_READ = 1’b1 MEM_WRITE = 1’b0
Sfârșit

`PROC_WB: începe
next_state = `PROC_FETCH
MEM_READ = 1’b1 MEM_WRITE = 1’b0
Sfârșit
endcase

Sfârșit
endmodule

modul PROC_SM (STATE, CLK, RST)
// lista de intrări
intrare CLK, RST
// lista rezultatelor
ieșire [2: 0] STATE

// lista de intrare
intrare CLK, RST
// lista de ieșire
ieșire STATE

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

reg PC_REG, INST_REG, SP_REF

`definiți PROC_FETCH 3’h0
`definiți PROC_DECODE 3’h1
`definiți PROC_EXE 3’h2
`definiți PROC_MEM 3’h3
`definiți PROC_WB 3’h4

// inițierea stării
iniţială
începe
state = 2’bxx
next_state = `PROC_FETCH
Sfârșit

// resetează gestionarea semnalului
mereu @ (posedge RST)
începe
state = `PROC_FETCH
next_state = `PROC_FETCH
Sfârșit
mereu @ (posedge CLK)
începe
state = next_state
Sfârșit
mereu @ (stat)
începe
if (state === `PROC_FETCH)
începe
next_state = `PROC_DECODE

print_instruction (INST_REG)
Sfârșit

if (state === `PROC_DECODE)
începe
next_state = `PROC_EXE

Sfârșit

if (state === `PROC_EXE)
începe
next_state = `PROC_MEM

print_instruction (SP_REF)
Sfârșit

if (state === `PROC_MEM)
începe
next_state = `PROC_WB

Sfârșit

if (state === `PROC_WB)
începe
next_state = `PROC_FETCH

print_instruction (PC_REG)
Sfârșit
Sfârșit

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] reg imediat [25: 0] adresa

începe

// analizați instrucțiunea
// de tip R

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

// Eu scriu
{opcode, rs, rt, imediat} = inst
// de tip J
{opcode, address} = inst
$ write („@% 6dns -> [0X% 08h]“, $ time, inst)
carcasă (opcode) // R-Type
6'h00: începe
case(funct)

6’h20: $ write („adăugați 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 („și r [% 02d], r [% 02d], r [% 02d]”, rs, rt, rd)
6’h25: $ write („sau r [% 02d], r [% 02d], r [% 02d]”, rs, rt, rd)
6’h27: $ write („nici 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)
implicit: $ write („”)
endcase
Sfârșit

// Eu scriu

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

// Tip J

6’h02: $ write („jmp 0X% 07h”, adresă)
6’h03: $ write („jal 0X% 07h”, adresa)
6’h1b: $ write („push”)
6’h1c: $ write („pop”)
implicit: $ write („”)
endcase
$ scrie („ n”)
Sfârșit
sarcină finală
modul final

Întrebări frecvente

1). Care este activitatea unei unități de control?

Lucrarea unității de control este de a dirija fluxul de date sau instrucțiuni pentru executarea de către procesorul unui computer. Controlează, gestionează și coordonează memoria principală, ALU, registre, unități de intrare și ieșire. Acesta preia instrucțiunile și generează semnale de control pentru execuție.

2). Ce este memoria de control?

Memoria de control este de obicei RAM sau ROM pentru a stoca adresa și datele din registrul de control.

3). Ce este unitatea de control Wilkes?

Secvențialul și circuite combinaționale ale unității de control cablate sunt înlocuite de unitatea de control Wilkes. Folosește o unitate de stocare pentru a stoca secvențele de instrucțiuni ale unui micro-program.

4). Ce este o unitate de control cablată?

Unitatea de control cablată generează semnalele de control prin schimbarea de la o stare la alta la fiecare impuls de ceas, fără nicio modificare fizică a circuitului. Generarea semnalelor de control depinde de registrul de instrucțiuni, de decodor și de semnale de întrerupere.

5). Ce este memoria de control?

Informațiile unității de control sau ale datelor sunt stocate temporar sau permanent în memoria de control.
Memoria de control este de două tipuri. Acestea sunt memorie cu acces aleatoriu (RAM) și memorie numai în citire (ROM).

Astfel, este vorba despre definiție, componente, proiectare, diagramă, funcții și tipuri de unitate de control . Iată o întrebare pentru dvs. „Care este scopul registrului de adrese de control?”