หน่วยควบคุมคืออะไร: ส่วนประกอบและการออกแบบ

หน่วยควบคุมเป็นส่วนประกอบหลักของหน่วยประมวลผลกลาง (CPU) ในคอมพิวเตอร์ที่สามารถสั่งการการทำงานระหว่างการทำงานของโปรแกรมโดย โปรเซสเซอร์ /คอมพิวเตอร์. หน้าที่หลักของชุดควบคุมคือการดึงข้อมูลและดำเนินการคำสั่งจากหน่วยความจำของคอมพิวเตอร์ รับคำสั่ง / ข้อมูลอินพุตจากผู้ใช้และแปลงเป็น สัญญาณควบคุม ซึ่งจะมอบให้กับ CPU เพื่อดำเนินการต่อไป รวมเป็นส่วนหนึ่งของสถาปัตยกรรมฟอนนอยมันน์ที่พัฒนาโดย John Neumann มีหน้าที่ในการให้สัญญาณเวลาและสัญญาณควบคุมและสั่งการทำงานของโปรแกรมโดย CPU รวมเป็นส่วนภายในของ CPU ในคอมพิวเตอร์สมัยใหม่ บทความนี้อธิบายข้อมูลทั้งหมดเกี่ยวกับชุดควบคุม

ชุดควบคุมคืออะไร?

ส่วนประกอบที่รับสัญญาณอินพุต / ข้อมูล / คำสั่งจากผู้ใช้และแปลงเป็นสัญญาณควบคุมสำหรับการดำเนินการใน CPU ควบคุมและสั่งการหน่วยความจำหลักหน่วยเลขคณิตและลอจิก (ALU) อุปกรณ์อินพุตและเอาต์พุตและยังรับผิดชอบคำสั่งที่ส่งไปยัง CPU ของคอมพิวเตอร์ ดึงคำแนะนำจากไฟล์ หน่วยความจำหลัก ของโปรเซสเซอร์และส่งไปยังรีจิสเตอร์คำสั่งโปรเซสเซอร์ซึ่งมีรีจิสเตอร์เนื้อหา

แผนภาพบล็อกหน่วยควบคุม

หน่วยควบคุมจะแปลงอินพุตเป็นสัญญาณควบคุมจากนั้นส่งไปยังโปรเซสเซอร์และสั่งการทำงานของโปรแกรม การดำเนินการที่ต้องดำเนินการจะถูกกำกับโดยโปรเซสเซอร์บนคอมพิวเตอร์ หน่วยประมวลผลกลางส่วนใหญ่ (CPU) และ หน่วยประมวลผลกราฟิก (GPU) ต้องการชุดควบคุมเป็นส่วนภายใน แผนภาพบล็อกของชุดควบคุมแสดงไว้ด้านบน

ส่วนประกอบของชุดควบคุม

ส่วนประกอบของหน่วยนี้เป็นคำสั่ง ลงทะเบียน , สัญญาณควบคุมภายใน CPU, สัญญาณควบคุมเข้า / ออกจากบัส, บัสควบคุม, แฟล็กอินพุตและสัญญาณนาฬิกา

ส่วนประกอบของชุดควบคุมเดินสายคือรีจิสเตอร์คำสั่ง (มีฟิลด์ opcode และแอดเดรส) หน่วยจับเวลาสถานะการควบคุม เครื่องกำเนิดไฟฟ้า เมทริกซ์การสร้างสัญญาณควบคุมและตัวถอดรหัสคำสั่ง
ส่วนประกอบของชุดควบคุมที่ตั้งโปรแกรมไมโครคือตัวสร้างที่อยู่ถัดไปทะเบียนที่อยู่ควบคุมหน่วยความจำควบคุมและทะเบียนข้อมูลควบคุม

ฟังก์ชั่น

หน้าที่ของชุดควบคุม รวมสิ่งต่อไปนี้

• มันกำกับการไหลของลำดับข้อมูลระหว่างโปรเซสเซอร์และอุปกรณ์อื่น ๆ
• สามารถตีความคำสั่งและควบคุมการไหลของข้อมูลในโปรเซสเซอร์
• สร้างลำดับของสัญญาณควบคุมจากคำสั่งหรือคำสั่งที่ได้รับจากการลงทะเบียนคำสั่ง
• มีหน้าที่ควบคุมหน่วยประมวลผลเช่น ALU บัฟเฟอร์ข้อมูลและรีจิสเตอร์ใน CPU ของคอมพิวเตอร์
• มีความสามารถในการดึงข้อมูลถอดรหัสจัดการการดำเนินการและจัดเก็บผลลัพธ์
• ไม่สามารถประมวลผลและจัดเก็บข้อมูลได้
• ในการถ่ายโอนข้อมูลจะสื่อสารกับอุปกรณ์อินพุตและเอาต์พุตและควบคุมหน่วยทั้งหมดของคอมพิวเตอร์

การออกแบบชุดควบคุม

การออกแบบนี้สามารถทำได้โดยใช้สอง ประเภทของชุดควบคุม ซึ่งรวมถึงสิ่งต่อไปนี้

• ใช้ Hardwire
• ตามไมโครโปรแกรม (ระดับเดียวและสองระดับ)

หน่วยควบคุมเดินสาย

การออกแบบพื้นฐานของชุดควบคุมเดินสายไฟแสดงไว้ด้านบน ในประเภทนี้สัญญาณควบคุมถูกสร้างขึ้นโดยฮาร์ดแวร์พิเศษ วงจรลอจิก โดยไม่มีการเปลี่ยนแปลงโครงสร้างของวงจร ด้วยเหตุนี้สัญญาณที่สร้างขึ้นจะไม่สามารถแก้ไขได้สำหรับการดำเนินการในโปรเซสเซอร์

ข้อมูลพื้นฐานของ opcode (รหัสการทำงานของคำสั่งจะถูกส่งไปยังตัวถอดรหัสคำสั่งสำหรับการถอดรหัสคำสั่ง ตัวถอดรหัส คือชุดตัวถอดรหัสสำหรับถอดรหัสข้อมูลประเภทต่างๆใน opcode ส่งผลให้สัญญาณเอาต์พุตซึ่งมีค่าของสัญญาณที่ใช้งานอยู่ซึ่งกำหนดให้เป็นอินพุตไปยังเมทริกซ์เจเนอเรเตอร์เพื่อสร้างสัญญาณควบคุมสำหรับการทำงานของโปรแกรมโดยโปรเซสเซอร์ของคอมพิวเตอร์

หน่วยควบคุมที่ใช้ Hardwire

เมทริกซ์เจเนอเรเตอร์แสดงสถานะของหน่วยควบคุมและสัญญาณออกจากโปรเซสเซอร์ (สัญญาณขัดจังหวะ) เมทริกซ์ถูกสร้างขึ้นเป็นไฟล์ อาร์เรย์ลอจิกที่ตั้งโปรแกรมได้ . สัญญาณควบคุมที่สร้างโดยเมทริกซ์เจเนอเรเตอร์จะได้รับเป็นอินพุตไปยังเมทริกซ์เครื่องกำเนิดไฟฟ้าถัดไปและรวมกับสัญญาณเวลาของหน่วยจับเวลาที่มีรูปแบบสี่เหลี่ยม

สำหรับการดึงคำสั่งใหม่ชุดควบคุมจะกลายเป็นขั้นตอนเริ่มต้นสำหรับการดำเนินการคำสั่งใหม่ ชุดควบคุมยังคงอยู่ในระยะเริ่มต้นหรือระยะแรกตราบเท่าที่สัญญาณเวลาสัญญาณอินพุตและสถานะของคำสั่งของคอมพิวเตอร์ไม่เปลี่ยนแปลง การเปลี่ยนแปลงสถานะของชุดควบคุมสามารถเกิดขึ้นได้หากมีการเปลี่ยนแปลงใด ๆ ในสัญญาณที่สร้างขึ้น

เมื่อเกิดสัญญาณภายนอกหรือการขัดจังหวะหน่วยควบคุมจะไปยังสถานะถัดไปและดำเนินการประมวลผลสัญญาณขัดจังหวะ แฟล็กและสถานะถูกใช้เพื่อเลือกสถานะที่ต้องการเพื่อดำเนินการตามรอบการดำเนินการของคำสั่ง

ในสถานะสุดท้ายหน่วยควบคุมจะดึงคำสั่งถัดไปและส่งเอาต์พุตไปยังตัวนับโปรแกรมจากนั้นไปที่รีจิสเตอร์ที่อยู่หน่วยความจำไปยังรีจิสเตอร์บัฟเฟอร์จากนั้นไปที่รีจิสเตอร์คำสั่งเพื่ออ่านคำสั่ง สุดท้ายหากคำสั่งสุดท้าย (ซึ่งเรียกโดยชุดควบคุม) เป็นคำสั่งสิ้นสุดคำสั่งนั้นจะเข้าสู่สถานะการทำงานของโปรเซสเซอร์และรอจนกว่าผู้ใช้จะสั่งโปรแกรมถัดไป

หน่วยควบคุมโปรแกรมไมโคร

ในประเภทนี้ที่เก็บควบคุมจะใช้เพื่อเก็บสัญญาณควบคุมที่เข้ารหัสระหว่างการทำงานของโปรแกรม สัญญาณควบคุมจะไม่ถูกสร้างขึ้นทันทีและถอดรหัสเนื่องจากไมโครโปรแกรมเก็บฟิลด์แอดเดรสไว้ในที่เก็บควบคุม กระบวนการทั้งหมดเป็นระดับเดียว

การดำเนินการขนาดเล็กจะทำเพื่อดำเนินการตามคำสั่งไมโครในโปรแกรม แผนภาพบล็อกของชุดควบคุมโปรแกรมไมโครแสดงไว้ด้านบน จากแผนภาพที่อยู่ของคำสั่งไมโครจะได้รับจากรีจิสเตอร์ที่อยู่หน่วยความจำควบคุม ข้อมูลทั้งหมดของชุดควบคุมจะถูกเก็บไว้อย่างถาวรในหน่วยความจำควบคุมที่เรียกว่า ROM

ชุดควบคุมที่ใช้ไมโครโปรแกรม

ไมโครคำสั่งจากหน่วยความจำควบคุมจะถูกควบคุมโดยรีจิสเตอร์ควบคุม เนื่องจากคำสั่งไมโครอยู่ในรูปแบบของคำควบคุม (มีค่าการควบคุมไบนารี) ที่ต้องดำเนินการขนาดเล็กอย่างน้อย 1 รายการสำหรับการประมวลผลข้อมูล

ในระหว่างการดำเนินการของไมโครคำสั่งเครื่องกำเนิดที่อยู่ถัดไปจะคำนวณที่อยู่ถัดไปของคำสั่งไมโครแล้วส่งไปยังทะเบียนที่อยู่ควบคุมเพื่ออ่านคำสั่งไมโครถัดไป
ลำดับของการดำเนินการขนาดเล็กของไมโครโปรแกรมจะดำเนินการโดยตัวสร้างที่อยู่ถัดไปและทำหน้าที่เป็นซีเควนเซอร์ไมโครโปรแกรมเพื่อรับที่อยู่ลำดับเช่นอ่านจากหน่วยความจำควบคุม

รหัส Verilog สำหรับชุดควบคุม

รหัส Verilog สำหรับชุดควบคุมแสดงอยู่ด้านล่าง

รวม“ prj_definition.v”

โมดูล 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_RULT_ ZERO_TRATA

// สัญญาณเอาต์พุต
// ผลลัพธ์สำหรับไฟล์ register

เอาต์พุต [`DATA_INDEX_LIMIT: 0] RF_DATA_W
เอาต์พุต [`ADDRESS_INDEX_LIMIT: 0] RF_ADDR_W, RF_ADDR_R1, RF_ADDR_R2
เอาต์พุต RF_READ, RF_WRITE

// เอาต์พุตสำหรับ ALU
เอาต์พุต [`DATA_INDEX_LIMIT: 0] ALU_OP1, ALU_OP2
เอาต์พุต [`ALU_OPRN_INDEX_LIMIT: 0] ALU_OPRN

// เอาต์พุตสำหรับหน่วยความจำ
เอาต์พุต [`ADDRESS_INDEX_LIMIT: 0] MEM_ADDR
เอาต์พุต MEM_READ, MEM_WRITE

// สัญญาณอินพุต
อินพุต [`DATA_INDEX_LIMIT: 0] RF_DATA_R1, RF_DATA_R2, ALU_RESULT
อินพุต ZERO, CLK, RST

// สัญญาณเข้า
ขาเข้า [`DATA_INDEX_LIMIT: 0] MEM_DATA

// มุ้งรัฐ
ลวด [2: 0] proc_state

// เก็บค่าตัวนับโปรแกรมเก็บคำสั่งปัจจุบันลงทะเบียนตัวชี้สแต็ก

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

เสมอ @ (วางตัว CLK)
เริ่ม
ถ้า (RST)
สถานะ<= RST
อื่น
สถานะ<= next_state

จบ

เสมอ @ (รัฐ)
เริ่ม

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

กรณี (รัฐ)

`PROC_FETCH: เริ่มต้น
next_state = `PROC_DECODE
MEM_READ = 1’b1
RF_ADDR_R1 = 1’b0 RF_ADDR_R2 = 1’b0
RF_ADDR_W = 1’b1
จบ

`PROC_DECODE: เริ่มต้น
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
จบ

`PROC_EXE: เริ่มต้น
next_state = `PROC_MEM
ALU_OP1 = 1’b1 ALU_OP2 = 1’b1 ALU_OPRN = 1’b1
RF_ADDR_R1 = 1’b0
จบ

`PROC_MEM: เริ่มต้น
next_state = `PROC_WB
MEM_READ = 1’b1 MEM_WRITE = 1’b0
จบ

`PROC_WB: เริ่มต้น
next_state = `PROC_FETCH
MEM_READ = 1’b1 MEM_WRITE = 1’b0
จบ
endcase

จบ
endmodule

โมดูล PROC_SM (STATE, CLK, RST)
// รายการอินพุต
อินพุต CLK, RST
// รายการผลลัพธ์
เอาต์พุต [2: 0] STATE

// รายการอินพุต
อินพุต CLK, RST
// รายการผลลัพธ์
เอาท์พุท STATE

reg [2: 0] STATE
reg [1: 0] สถานะ
reg [1: 0] next_state

reg PC_REG, INST_REG, SP_REF

`กำหนด PROC_FETCH 3’h0
`กำหนด PROC_DECODE 3’h1
`กำหนด PROC_EXE 3’h2
`กำหนด PROC_MEM 3’h3
`กำหนด PROC_WB 3’h4

// การเริ่มต้นของสถานะ
เริ่มต้น
เริ่ม
state = 2’bxx
next_state = `PROC_FETCH
จบ

// รีเซ็ตการจัดการสัญญาณ
เสมอ @ (posedge RST)
เริ่ม
รัฐ = `PROC_FETCH
next_state = `PROC_FETCH
จบ
เสมอ @ (วางตัว CLK)
เริ่ม
state = next_state
จบ
เสมอ @ (รัฐ)
เริ่ม
ถ้า (สถานะ === `PROC_FETCH)
เริ่ม
next_state = `PROC_DECODE

print_instruction (INST_REG)
จบ

ถ้า (สถานะ === `PROC_DECODE)
เริ่ม
next_state = `PROC_EXE

จบ

ถ้า (state === `PROC_EXE)
เริ่ม
next_state = `PROC_MEM

print_instruction (SP_REF)
จบ

ถ้า (สถานะ === `PROC_MEM)
เริ่ม
next_state = `PROC_WB

จบ

ถ้า (สถานะ === `PROC_WB)
เริ่ม
next_state = `PROC_FETCH

print_instruction (PC_REG)
จบ
จบ

งาน print_instruction

อินพุต [`DATA_INDEX_LIMIT: 0] อินสแตนซ์

reg [5: 0] opcode
reg [4: 0] rs
reg [4: 0] rt
reg [4: 0] ถ
reg [4: 0] shamt reg [5: 0] funct reg [15: 0] ที่อยู่ reg [25: 0] ทันที

เริ่ม

// แยกวิเคราะห์คำสั่ง
// ประเภท R

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

// I-type
{opcode, rs, rt, ทันที} = inst
// ประเภท J
{opcode, address} = inst
$ write (“ @% 6dns -> [0X% 08h]“, $ time, inst)
กรณี (opcode) // R-Type
6'h00: เริ่ม
กรณี (ฟังก์ชัน)

6’h20: $ write (“ เพิ่ม 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 (“ และ r [% 02d], r [% 02d], r [% 02d]”, rs, rt, rd)
6’h25: $ write (“ หรือ 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)
ค่าเริ่มต้น: $ write (“”)
endcase
จบ

// I-type

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

// ประเภท J

6’h02: $ write (“ jmp 0X% 07h”, ที่อยู่)
6’h03: $ write (“ jal 0X% 07h”, ที่อยู่)
6’h1b: $ write (“ push”)
6’h1c: $ write (“ ป๊อป”)
ค่าเริ่มต้น: $ write (“”)
endcase
$ เขียน (“ n”)
จบ
งานสิ้นสุด
โมดูลท้าย

คำถามที่พบบ่อย

1). การทำงานของชุดควบคุมคืออะไร?

การทำงานของชุดควบคุมคือการกำหนดทิศทางการไหลของข้อมูลหรือคำแนะนำสำหรับการดำเนินการโดยโปรเซสเซอร์ของคอมพิวเตอร์ มันควบคุมจัดการและประสานหน่วยความจำหลัก, ALU, รีจิสเตอร์, อินพุตและยูนิตเอาต์พุต จะดึงคำแนะนำและสร้างสัญญาณควบคุมสำหรับการดำเนินการ

2). หน่วยความจำควบคุมคืออะไร?

หน่วยความจำควบคุมมักจะเป็น RAM หรือ ROM เพื่อเก็บที่อยู่และข้อมูลของทะเบียนควบคุม

3). ชุดควบคุม Wilkes คืออะไร?

ลำดับและ วงจรผสม ของชุดควบคุมเดินสายไฟจะถูกแทนที่ด้วยชุดควบคุม Wilkes ใช้หน่วยเก็บข้อมูลเพื่อจัดเก็บลำดับคำสั่งของไมโครโปรแกรม

4). ชุดควบคุมเดินสายไฟคืออะไร?

ชุดควบคุมแบบเดินสายจะสร้างสัญญาณควบคุมโดยเปลี่ยนจากสถานะหนึ่งไปเป็นอีกสถานะหนึ่งในทุกพัลส์นาฬิกาโดยไม่มีการเปลี่ยนแปลงทางกายภาพในวงจร การสร้างสัญญาณควบคุมขึ้นอยู่กับการลงทะเบียนคำสั่งตัวถอดรหัสและสัญญาณขัดจังหวะ

5). หน่วยความจำควบคุมคืออะไร?

ข้อมูลของชุดควบคุมหรือข้อมูลจะถูกเก็บไว้ในหน่วยความจำควบคุมชั่วคราวหรือถาวร
หน่วยความจำควบคุมมีสองประเภท หน่วยความจำเข้าถึงโดยสุ่ม (RAM) และหน่วยความจำแบบอ่านอย่างเดียว (ROM)

ดังนั้นทั้งหมดนี้จึงเกี่ยวกับความหมายส่วนประกอบการออกแบบแผนภาพฟังก์ชันและ ประเภทของชุดควบคุม . นี่คือคำถามสำหรับคุณ 'จุดประสงค์ของการลงทะเบียนที่อยู่ควบคุมคืออะไร'