Hva er kontrollenhet: komponenter og dens design

Prøv Instrumentet Vårt For Å Eliminere Problemer





Kontrollenheten er hovedkomponenten i en sentral prosesseringsenhet (CPU) på datamaskiner som kan styre operasjonene under gjennomføring av et program ved å prosessoren /datamaskin. Hovedfunksjonen til kontrollenheten er å hente og utføre instruksjoner fra minnet til en datamaskin. Den mottar inngangsinstruksjonen / informasjonen fra brukeren og konverterer den til styresignaler , som deretter blir gitt til CPU for videre kjøring. Det er inkludert som en del av Von Neumann-arkitekturen utviklet av John Neumann. Det er ansvarlig for å gi tidssignalene, og styresignalene og styrer gjennomføringen av et program av CPUen. Den er inkludert som en intern del av CPU-en i moderne datamaskiner. Denne artikkelen beskriver fullstendig informasjon om kontrollenheten.

Hva er kontrollenheten?

Komponenten som mottar inngangssignalet / informasjonen / instruksjonen fra brukeren og konverterer til styresignaler for utførelse i CPU. Den styrer og styrer hovedminnet, aritmetikk- og logikkenheten (ALU), inngangs- og utdataenheter, og er også ansvarlig for instruksjonene som sendes til CPU på en datamaskin. Den henter instruksjonene fra hovedminne av en prosessor og sendt til prosessorens instruksjonsregister, som inneholder registerinnhold.




Kontrolldiagramblokkdiagram

Kontrolldiagramblokkdiagram

Kontrollenheten konverterer inngangen til styresignaler og sendes deretter til prosessoren og styrer utførelsen av et program. Operasjonene som må utføres ledes av prosessoren på datamaskinen. Hovedsakelig Central Processing Unit (CPU) og Grafisk prosesseringsenhet (GPU) krever en kontrollenhet som den interne delen. Blokkdiagrammet til styreenheten er vist ovenfor.



Komponenter i en kontrollenhet

Komponentene til denne enheten er instruksjon registre , styresignaler i CPU, styresignaler til / fra bussen, kontrollbuss, inngangsflagg og kloksignaler.

Komponentene til Hardwired-kontrollenheten er instruksjonsregister (inneholder opcode og adressefelt), timing-enhet, kontrolltilstand generator , matriser for generering av styresignaler og instruksjonsdekoder
Komponentene til den mikroprogrammerte styringsenheten er neste adressegenerator, et kontrolladresseregister, kontrollminne og styringsregister.

Funksjoner

De kontrollenhetens funksjoner Inkluder følgende.


  • Den styrer datasekvensen mellom prosessoren og andre enheter.
  • Den kan tolke instruksjonene og kontrollere datastrømmen i prosessoren.
  • Den genererer sekvensen av styresignaler fra mottatte instruksjoner eller kommandoer fra instruksjonsregisteret.
  • Det har ansvaret for å kontrollere kjøringsenhetene som ALU, databuffere og registre i CPU på en datamaskin.
  • Den har muligheten til å hente, dekode, håndtere utførelsen og lagre resultatene.
  • Den kan ikke behandle og lagre dataene
  • For å overføre dataene kommuniserer den med inngangs- og utdataenhetene og styrer alle enhetene på datamaskinen.

Design av kontrollenhet

Utformingen av dette kan gjøres ved hjelp av to typer kontrollenhet som inkluderer følgende.

  • Hardwire basert
  • Mikroprogrammert basert (enkeltnivå og to-nivå)

Kablet kontrollenhet

Den grunnleggende utformingen av en kablet kontrollenhet er vist ovenfor. I denne typen genereres styresignalene av en spesiell maskinvare logikkrets uten noen endring i kretsens struktur. I dette kan ikke det genererte signalet modifiseres for utføring i prosessoren.

De grunnleggende dataene til en opcode (operasjonskoden til en instruksjon blir sendt til instruksjonsavkoderen for dekoding. Instruksjonen dekoder er settet med dekodere for å dekode forskjellige typer data i opkoden. Dette resulterer i utgangssignaler som inneholder verdier av aktive signaler som blir gitt som inngang til matrisegeneratoren for å generere styresignaler for utførelse av et program av prosessoren på datamaskinen.

Hardwire-basert kontrollenhet

Hardwire-basert kontrollenhet

Matrisegeneratoren gir tilstander til kontrollenheten og signalene ut fra prosessoren (avbruddssignaler). Matrise er bygget som programmerbar logisk matrise . Styresignalene generert av matrisegeneratoren blir gitt som inngang til neste generatormatrise og kombineres med tidssignalene til tidsenheten som inneholder rektangulære mønstre.

For å hente ny instruksjon blir styreenheten til et innledende trinn for gjennomføring av ny instruksjon. Kontrollenheten forblir i den innledende fasen eller første trinn så lenge tidssignalene, inngangssignalene og instruksjonstilstandene til en datamaskin er uendret. Endringen i kontrollenhetens tilstand kan økes hvis det er noen endring i noen av de genererte signalene.

Når et eksternt signal eller avbrudd oppstår, går kontrollenheten til neste tilstand og utfører behandlingen av avbruddssignalet. Flaggene og statene brukes til å velge de ønskede tilstandene for å utføre instruksjonens utførelsessyklus.

I den siste tilstanden henter kontrollenheten neste instruksjon og sender utgangen til programtelleren, deretter til minneadresseregisteret, til bufferregisteret, og deretter til instruksjonsregisteret for å lese instruksjonen. Til slutt, hvis den siste instruksjonen (som hentes av kontrollenheten) er sluttinstruksjon, så går den til driftstilstanden til prosessoren og venter til brukeren styrer neste program.

Mikroprogrammert kontrollenhet

I denne typen brukes styrelageret til å lagre styresignalene som er kodet under utførelsen av et program. Kontrollsignalet genereres ikke umiddelbart og dekodes fordi mikroprogrammet lagrer adressefeltet i kontrollageret. Hele prosessen er på ett nivå.

Mikrooperasjonene gjøres for gjennomføring av mikroinstruksjoner i programmet. Blokkdiagrammet til den mikroprogrammerte kontrollenheten er vist ovenfor. Fra diagrammet er adressen til mikroinstruksjonen hentet fra registerminnets adresseregister. All informasjonen til kontrollenheten er permanent lagret i kontrollminnet kalt ROM.

Mikroprogrammert kontrollenhet

Mikroprogrammert kontrollenhet

Mikroinstruksjonen fra kontrollminnet holdes av kontrollregisteret. Siden mikroinstruksjonen er i form av kontrollord (inneholder binære kontrollverdier) som trenger 1 eller flere mikrooperasjoner som skal utføres for databehandlingen.

Under utførelsen av mikroinstruksjoner beregnet neste adressegenerator neste adresse til mikroinstruksjonen og sendte deretter til kontrolladresseregisteret for å lese neste mikroinstruksjon.
Sekvensen av mikrooperasjoner til et mikroprogram utføres av neste adressegenerator og fungerer som mikroprogramsekvensator for å få sekvensadressen, dvs. lese fra kontrollminnet.

Verilog-kode for kontrollenheten

Verilog-kode for kontrollenhet er vist nedenfor.

`inkluderer“ 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_

// Utgangssignaler
// Utganger for registerfil

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

// Utganger for ALU
utgang [`DATA_INDEX_LIMIT: 0] ALU_OP1, ALU_OP2
utgang [`ALU_OPRN_INDEX_LIMIT: 0] ALU_OPRN

// Utganger for minne
utgang [`ADDRESS_INDEX_LIMIT: 0] MEM_ADDR
utgang MEM_READ, MEM_WRITE

// Inngangssignaler
inngang [`DATA_INDEX_LIMIT: 0] RF_DATA_R1, RF_DATA_R2, ALU_RESULT
inngang ZERO, CLK, RST

// Innesignal
ut [`DATA_INDEX_LIMIT: 0] MEM_DATA

// Statlige nett
wire [2: 0] proc_state

// holder programtellerverdi, lagrer gjeldende instruksjon, stabler pekerregister

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

alltid @ (posedge CLK)
begynne
hvis (RST)
stat<= RST
ellers
stat<= next_state

slutt

alltid @ (tilstand)
begynne

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

sak (tilstand)

`PROC_FETCH: begynn
neste_stat = `PROC_DECODE
MEM_READ = 1’b1
RF_ADDR_R1 = 1’b0 RF_ADDR_R2 = 1’b0
RF_ADDR_W = 1’b1
slutt

`PROC_DECODE: begynn
neste_stat = `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
slutt

`PROC_EXE: begynn
neste_stat = `PROC_MEM
ALU_OP1 = 1’b1 ALU_OP2 = 1’b1 ALU_OPRN = 1’b1
RF_ADDR_R1 = 1’b0
slutt

`PROC_MEM: begynn
neste_stat = `PROC_WB
MEM_READ = 1’b1 MEM_WRITE = 1’b0
slutt

`PROC_WB: begynn
neste_stat = `PROC_FETCH
MEM_READ = 1’b1 MEM_WRITE = 1’b0
slutt
endcase

slutt
endemodul

modul PROC_SM (STATE, CLK, RST)
// liste over innganger
inngang CLK, RST
// liste over utganger
utgang [2: 0] STATE

// inngangsliste
inngang CLK, RST
// utgangsliste
utgang STATE

reg [2: 0] STAT
reg [1: 0] tilstand
reg [1: 0] neste_stat

reg PC_REG, INST_REG, SP_REF

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

// initiering av staten
første
begynne
tilstand = 2’bxx
neste_stat = `PROC_FETCH
slutt

// tilbakestille signalhåndtering
alltid @ (posedge RST)
begynne
tilstand = `PROC_FETCH
neste_stat = `PROC_FETCH
slutt
alltid @ (posedge CLK)
begynne
tilstand = neste_stat
slutt
alltid @ (tilstand)
begynne
hvis (oppgi === `PROC_FETCH)
begynne
neste_stat = `PROC_DECODE

utskriftsinstruksjon (INST_REG)
slutt

hvis (oppgi === `PROC_DECODE)
begynne
neste_stat = `PROC_EXE

slutt

hvis (oppgi === `PROC_EXE)
begynne
neste_stat = `PROC_MEM

utskriftsinstruksjon (SP_REF)
slutt

hvis (oppgi === `PROC_MEM)
begynne
neste_stat = `PROC_WB

slutt

hvis (oppgi === `PROC_WB)
begynne
neste_stat = `PROC_FETCH

utskriftsinstruksjon (PC_REG)
slutt
slutt

oppgave utskriftsinstruksjon

inngang [`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] umiddelbar reg [25: 0] adresse

begynne

// analyser instruksjonene
// R-type

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

// Jeg-type
{opcode, rs, rt, umiddelbar} = inst
// J-type
{opcode, adresse} = inst
$ skriv (“@% 6dns -> [0X% 08h]“, $ tid, inst)
sak (opcode) // R-Type
6'h00: start
sak (funksjon)

6’h20: $ skriv (“legg til [% 02d], r [% 02d], r [% 02d]”, rs, rt, rd)
6’h22: $ skriv (“sub r [% 02d], r [% 02d], r [% 02d]”, rs, rt, rd)
6’h2c: $ skriv (“mul r [% 02d], r [% 02d], r [% 02d]”, rs, rt, rd)
6’h24: $ skriv (“og r [% 02d], r [% 02d], r [% 02d]”, rs, rt, rd)
6’h25: $ skriv (“eller r [% 02d], r [% 02d], r [% 02d]”, rs, rt, rd)
6’h27: $ skriv (“nor r [% 02d], r [% 02d], r [% 02d]”, rs, rt, rd)
6’h2a: $ skriv (“slt r [% 02d], r [% 02d], r [% 02d]”, rs, rt, rd)
6’h00: $ skriv (“sll r [% 02d],% 2d, r [% 02d]”, rs, shamt, rd)
6’h02: $ skriv (“srl r [% 02d], 0X% 02h, r [% 02d]”, rs, shamt, rd)
6’h08: $ skriv (“jr r [% 02d]”, rs)
standard: $ skriv (“”)
endcase
slutt

// Jeg-type

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

// J-Type

6’h02: $ skriv (“jmp 0X% 07h”, adresse)
6’h03: $ skriv (“jal 0X% 07h”, adresse)
6’h1b: $ skriv (“push”)
6’h1c: $ skriv (“pop”)
standard: $ skriv (“”)
endcase
$ skriv (“ n”)
slutt
sluttoppgave
sluttmodul

Vanlige spørsmål

1). Hva er arbeidet med en kontrollenhet?

Kontrollenhetens arbeid er å lede datastrømmen eller instruksjoner for utførelse av prosessoren av en datamaskin. Den styrer, administrerer og koordinerer hovedminne, ALU, registre, inngang og utgangsenheter. Den henter instruksjonene og genererer styresignaler for utførelsen.

2). Hva er kontrollminnet?

Kontrollminne er vanligvis RAM eller ROM for å lagre adressen og dataene til kontrollregisteret.

3). Hva er Wilkes kontrollenhet?

Den sekvensielle og kombinasjonskretser av den fastkoblede kontrollenheten erstattes av Wilkes-kontrollenheten. Den bruker en lagringsenhet til å lagre sekvensene av instruksjonene til et mikroprogram.

4). Hva er en fast kablet kontrollenhet?

Den fastkoblede kontrollenheten genererer styresignalene ved å bytte fra en tilstand til en annen tilstand i hver klokkepuls uten noen fysisk endring i kretsen. Generering av styresignaler avhenger av instruksjonsregister, dekoder og avbruddssignaler.

5). Hva er kontrollminnet?

Informasjonen til kontrollenheten eller dataene lagres midlertidig eller permanent i kontrollminnet.
Kontrollminne er av to typer. De er Random Access Memory (RAM) og Read-Only Memory (ROM).

Dermed handler alt om definisjonen, komponenter, design, diagram, funksjoner og typer kontrollenhet . Her er et spørsmål til deg: 'Hva er formålet med kontrolladresseregisteret?'