제어장치¶

개요¶

제어장치(Control Unit)는 CPU의 핵심 구성요소로, 명령어를 해독하고 적절한 제어 신호를 생성하여 CPU 내의 모든 구성요소를 조율합니다. 이 레슨에서는 제어장치의 역할, 하드와이어드 제어와 마이크로프로그램 제어의 두 가지 구현 방식, 그리고 마이크로명령어의 구조에 대해 학습합니다.

난이도: ⭐⭐⭐

선수 지식: CPU 구조 기초, 논리 회로, 상태 기계

목차¶

제어장치의 역할
하드와이어드 제어
마이크로프로그램 제어
제어 신호 생성
마이크로명령어
연습 문제

1. 제어장치의 역할¶

1.1 제어장치의 기본 기능¶

┌──────────────────────────────────────────────────────────────────────┐
│                         제어장치의 역할                               │
│                                                                      │
│  ┌─────────────────────────────────────────────────────────────┐    │
│  │                    입력 (Inputs)                             │    │
│  │                                                             │    │
│  │    ┌─────────────┐    ┌─────────────┐    ┌─────────────┐   │    │
│  │    │  명령어 IR  │    │   클럭      │    │  상태 신호  │   │    │
│  │    │  (Opcode,   │    │  (Clock)    │    │  (Flags,    │   │    │
│  │    │   Funct)    │    │             │    │   Ready)    │   │    │
│  │    └──────┬──────┘    └──────┬──────┘    └──────┬──────┘   │    │
│  └───────────┼──────────────────┼──────────────────┼───────────┘    │
│              │                  │                  │                 │
│              ▼                  ▼                  ▼                 │
│  ┌─────────────────────────────────────────────────────────────┐    │
│  │                      제어 장치                               │    │
│  │         (Control Unit)                                      │    │
│  │                                                             │    │
│  │    ┌────────────────────────────────────────────────┐      │    │
│  │    │           제어 로직 / 마이크로프로그램          │      │    │
│  │    └────────────────────────────────────────────────┘      │    │
│  └─────────────────────────────────────────────────────────────┘    │
│              │                  │                  │                 │
│              ▼                  ▼                  ▼                 │
│  ┌─────────────────────────────────────────────────────────────┐    │
│  │                   출력 (Outputs) - 제어 신호                 │    │
│  │                                                             │    │
│  │    ┌─────────┐ ┌─────────┐ ┌─────────┐ ┌─────────────────┐ │    │
│  │    │ RegWrite│ │ ALUOp   │ │ MemRead │ │ MemWrite        │ │    │
│  │    │ ALUSrc  │ │ Branch  │ │ MemtoReg│ │ PCSrc           │ │    │
│  │    └─────────┘ └─────────┘ └─────────┘ └─────────────────┘ │    │
│  └─────────────────────────────────────────────────────────────┘    │
│                                                                      │
└──────────────────────────────────────────────────────────────────────┘

1.2 제어장치의 주요 작업¶

작업	설명
명령어 해독	IR의 opcode와 function 필드를 분석하여 명령어 종류 파악
타이밍 생성	각 작업의 실행 순서와 시점 결정
제어 신호 생성	데이터패스의 각 구성요소를 제어하는 신호 출력
상태 관리	현재 실행 상태 추적 및 다음 상태 결정
예외 처리	인터럽트, 오류 등 예외 상황 감지 및 처리

1.3 제어 신호와 데이터패스¶

┌───────────────────────────────────────────────────────────────────────────┐
│                    제어 신호와 데이터패스의 관계                           │
│                                                                           │
│                          ┌────────────────┐                               │
│                          │   제어 장치    │                               │
│                          └───────┬────────┘                               │
│                                  │                                        │
│           ┌──────────────────────┼──────────────────────┐                 │
│           │                      │                      │                 │
│           ▼                      ▼                      ▼                 │
│  ┌─────────────────┐  ┌─────────────────┐  ┌─────────────────┐           │
│  │  레지스터 제어   │  │    ALU 제어     │  │   메모리 제어   │           │
│  │                 │  │                 │  │                 │           │
│  │  - RegWrite     │  │  - ALUOp        │  │  - MemRead      │           │
│  │  - RegDst       │  │  - ALUSrc       │  │  - MemWrite     │           │
│  └────────┬────────┘  └────────┬────────┘  └────────┬────────┘           │
│           │                    │                    │                     │
│           ▼                    ▼                    ▼                     │
│  ┌─────────────────────────────────────────────────────────────┐         │
│  │                       데이터패스                             │         │
│  │                                                             │         │
│  │  ┌──────────┐     ┌──────────┐     ┌──────────────────┐    │         │
│  │  │ 레지스터 │────►│   ALU    │────►│     메모리       │    │         │
│  │  │   파일   │     │          │     │                  │    │         │
│  │  └──────────┘     └──────────┘     └──────────────────┘    │         │
│  │       ▲                                     │              │         │
│  │       └─────────────────────────────────────┘              │         │
│  │                    (Write Back)                            │         │
│  └─────────────────────────────────────────────────────────────┘         │
│                                                                           │
└───────────────────────────────────────────────────────────────────────────┘

2. 하드와이어드 제어¶

2.1 하드와이어드 제어 개념¶

하드와이어드(Hardwired) 제어는 제어 논리를 조합 논리 회로와 순차 논리 회로로 직접 구현하는 방식입니다.

┌─────────────────────────────────────────────────────────────────────┐
│                     하드와이어드 제어장치                            │
│                                                                     │
│    IR [31:26]        ┌─────────────────────────────────────────┐   │
│    (Opcode)   ──────►│                                         │   │
│                      │        조합 논리 회로                    │   │
│    IR [5:0]          │     (Combinational Logic)               │   │
│    (Funct)    ──────►│                                         │──► 제어 신호
│                      │     - 디코더                            │   │
│    상태 플래그       │     - 논리 게이트 (AND, OR)             │   │
│    (Flags)    ──────►│     - 멀티플렉서                        │   │
│                      └─────────────────────────────────────────┘   │
│                                    ▲                               │
│                                    │                               │
│                      ┌─────────────┴─────────────┐                 │
│                      │                           │                 │
│    ┌─────────────────┴───────────────────────────┴───────────┐    │
│    │                    타이밍/시퀀서                         │    │
│    │         (상태 레지스터, 카운터, 디코더)                 │    │
│    │                                                         │    │
│    │    ┌────────┐    ┌────────┐    ┌────────┐              │    │
│    │    │ 상태   │───►│ 상태   │───►│ 타이밍 │              │    │
│    │    │레지스터│    │디코더  │    │  신호  │              │    │
│    │    └────────┘    └────────┘    └────────┘              │    │
│    └─────────────────────────────────────────────────────────┘    │
│                      ▲                                             │
│    클럭 ─────────────┘                                             │
│                                                                     │
└─────────────────────────────────────────────────────────────────────┘

2.2 MIPS 단일 사이클 제어장치¶

┌─────────────────────────────────────────────────────────────────────┐
│                MIPS 단일 사이클 제어 (간략화)                        │
│                                                                     │
│    Opcode [5:0]                                                     │
│        │                                                            │
│        ▼                                                            │
│    ┌───────────────────────────────────────────────────────────┐   │
│    │                      Main Decoder                          │   │
│    ├───────────────────────────────────────────────────────────┤   │
│    │  Opcode  │ RegDst │ ALUSrc │ MemtoReg │ RegWrite │ ...    │   │
│    ├──────────┼────────┼────────┼──────────┼──────────┼────────┤   │
│    │ R-type   │   1    │   0    │    0     │    1     │        │   │
│    │ (000000) │        │        │          │          │        │   │
│    ├──────────┼────────┼────────┼──────────┼──────────┼────────┤   │
│    │   lw     │   0    │   1    │    1     │    1     │        │   │
│    │ (100011) │        │        │          │          │        │   │
│    ├──────────┼────────┼────────┼──────────┼──────────┼────────┤   │
│    │   sw     │   x    │   1    │    x     │    0     │        │   │
│    │ (101011) │        │        │          │          │        │   │
│    ├──────────┼────────┼────────┼──────────┼──────────┼────────┤   │
│    │   beq    │   x    │   0    │    x     │    0     │        │   │
│    │ (000100) │        │        │          │          │        │   │
│    └──────────┴────────┴────────┴──────────┴──────────┴────────┘   │
│                                                                     │
└─────────────────────────────────────────────────────────────────────┘

2.3 ALU 제어 유닛¶

┌─────────────────────────────────────────────────────────────────────┐
│                        ALU 제어 유닛                                 │
│                                                                     │
│    ALUOp (2비트)      Funct (6비트)                                 │
│        │                  │                                         │
│        │                  │                                         │
│        ▼                  ▼                                         │
│    ┌──────────────────────────────────────────┐                    │
│    │            ALU Control Unit              │                    │
│    │                                          │                    │
│    │    ┌────────┬────────┬────────────────┐ │                    │
│    │    │ ALUOp  │ Funct  │ ALU Operation  │ │                    │
│    │    ├────────┼────────┼────────────────┤ │                    │
│    │    │  00    │xxxxxx  │ Add (lw/sw)    │ │                    │
│    │    │  01    │xxxxxx  │ Sub (beq)      │ │                    │
│    │    │  10    │100000  │ Add            │ │                    │
│    │    │  10    │100010  │ Sub            │ │                    │
│    │    │  10    │100100  │ And            │ │                    │
│    │    │  10    │100101  │ Or             │ │                    │
│    │    │  10    │101010  │ Slt            │ │                    │
│    │    └────────┴────────┴────────────────┘ │                    │
│    └──────────────────────────────────────────┘                    │
│                    │                                                │
│                    ▼                                                │
│            ALU Control (4비트)                                      │
│                                                                     │
│    ┌───────────────────────────────────────────────────────┐       │
│    │  ALU Control │     Operation      │                   │       │
│    ├──────────────┼────────────────────┤                   │       │
│    │     0000     │       AND          │                   │       │
│    │     0001     │       OR           │                   │       │
│    │     0010     │       Add          │                   │       │
│    │     0110     │       Sub          │                   │       │
│    │     0111     │       Slt          │                   │       │
│    │     1100     │       NOR          │                   │       │
│    └──────────────┴────────────────────┘                   │       │
│                                                                     │
└─────────────────────────────────────────────────────────────────────┘

2.4 다중 사이클 하드와이어드 제어¶

┌─────────────────────────────────────────────────────────────────────┐
│               다중 사이클 제어: 유한 상태 기계 (FSM)                 │
│                                                                     │
│                          ┌──────────┐                               │
│                     ┌───►│  State 0 │◄────────────────┐             │
│                     │    │  (IF)    │                 │             │
│                     │    └────┬─────┘                 │             │
│                     │         │                       │             │
│                     │         ▼                       │             │
│                     │    ┌──────────┐                 │             │
│                     │    │  State 1 │                 │             │
│                     │    │  (ID)    │                 │             │
│                     │    └────┬─────┘                 │             │
│                     │         │                       │             │
│            ┌────────┴─────────┼─────────┬─────────────┤             │
│            │                  │         │             │             │
│            ▼                  ▼         ▼             │             │
│       ┌──────────┐      ┌──────────┐ ┌──────────┐    │             │
│       │  State 2 │      │  State 6 │ │  State 8 │    │             │
│       │ (MemAddr)│      │  (R-EX)  │ │  (BEQ)   │────┘             │
│       └────┬─────┘      └────┬─────┘ └──────────┘                   │
│            │                 │                                       │
│       ┌────┴────┐            │                                       │
│       │         │            │                                       │
│       ▼         ▼            ▼                                       │
│  ┌──────────┐ ┌──────────┐ ┌──────────┐                             │
│  │  State 3 │ │  State 5 │ │  State 7 │                             │
│  │ (MemRead)│ │(MemWrite)│ │  (R-WB)  │                             │
│  └────┬─────┘ └────┬─────┘ └────┬─────┘                             │
│       │            │            │                                    │
│       ▼            │            │                                    │
│  ┌──────────┐      │            │                                    │
│  │  State 4 │      │            │                                    │
│  │  (LW-WB) │      │            │                                    │
│  └────┬─────┘      │            │                                    │
│       │            │            │                                    │
│       └────────────┴────────────┴──────────────────────►(State 0)   │
│                                                                     │
└─────────────────────────────────────────────────────────────────────┘

2.5 상태별 제어 신호¶

┌─────────────────────────────────────────────────────────────────────────────┐
│                       상태별 제어 신호 테이블                                │
├───────┬───────┬───────┬───────┬───────┬───────┬───────┬───────┬────────────┤
│ State │ PCWrite│IRWrite│RegWrite│ALUSrcA│ALUSrcB│ALUOp │MemRead│ 설명      │
├───────┼───────┼───────┼───────┼───────┼───────┼───────┼───────┼────────────┤
│   0   │   1   │   1   │   0   │   0   │  01   │  00   │   1   │ IF         │
│  (IF) │       │       │       │       │       │       │       │명령어 인출 │
├───────┼───────┼───────┼───────┼───────┼───────┼───────┼───────┼────────────┤
│   1   │   0   │   0   │   0   │   0   │  11   │  00   │   0   │ ID         │
│  (ID) │       │       │       │       │       │       │       │명령어 해독 │
├───────┼───────┼───────┼───────┼───────┼───────┼───────┼───────┼────────────┤
│   2   │   0   │   0   │   0   │   1   │  10   │  00   │   0   │ MemAddr    │
│       │       │       │       │       │       │       │       │주소 계산   │
├───────┼───────┼───────┼───────┼───────┼───────┼───────┼───────┼────────────┤
│   3   │   0   │   0   │   0   │   0   │  00   │  00   │   1   │ MemRead    │
│       │       │       │       │       │       │       │       │메모리 읽기 │
├───────┼───────┼───────┼───────┼───────┼───────┼───────┼───────┼────────────┤
│   4   │   0   │   0   │   1   │   0   │  00   │  00   │   0   │ LW WB      │
│       │       │       │       │       │       │       │       │Load 쓰기   │
├───────┼───────┼───────┼───────┼───────┼───────┼───────┼───────┼────────────┤
│   6   │   0   │   0   │   0   │   1   │  00   │  10   │   0   │ R-type EX  │
│       │       │       │       │       │       │       │       │R-type 실행 │
├───────┼───────┼───────┼───────┼───────┼───────┼───────┼───────┼────────────┤
│   7   │   0   │   0   │   1   │   0   │  00   │  00   │   0   │ R-type WB  │
│       │       │       │       │       │       │       │       │R-type 쓰기 │
└───────┴───────┴───────┴───────┴───────┴───────┴───────┴───────┴────────────┘

2.6 하드와이어드 제어의 장단점¶

장점	단점
빠른 속도 (전파 지연만 존재)	설계 복잡도 높음
최적화 가능	수정/확장 어려움
면적 효율적 (단순 명령어 집합)	디버깅 어려움
RISC 프로세서에 적합	새 명령어 추가 시 회로 재설계 필요

3. 마이크로프로그램 제어¶

3.1 마이크로프로그램 제어 개념¶

마이크로프로그램 제어는 제어 신호를 마이크로프로그램(펌웨어)으로 저장하고, 이를 순차적으로 실행하여 제어 신호를 생성하는 방식입니다.

┌─────────────────────────────────────────────────────────────────────────┐
│                      마이크로프로그램 제어장치                           │
│                                                                         │
│    IR (Opcode)                                                          │
│        │                                                                │
│        ▼                                                                │
│    ┌──────────────────┐                                                │
│    │   Mapping ROM    │                                                │
│    │  (주소 매핑)     │                                                │
│    └────────┬─────────┘                                                │
│             │ 시작 주소                                                 │
│             ▼                                                           │
│    ┌────────────────────────────────────────────────────────────┐      │
│    │                                                            │      │
│    │    ┌─────────────┐                                        │      │
│    │    │  MicroPC    │◄─────────────────────────────┐         │      │
│    │    │ (마이크로   │                              │         │      │
│    │    │  프로그램   │                              │         │      │
│    │    │  카운터)    │                              │         │      │
│    │    └──────┬──────┘                              │         │      │
│    │           │                                      │         │      │
│    │           ▼                                      │         │      │
│    │    ┌────────────────────────────────────┐      │         │      │
│    │    │      Control Store (ROM)           │      │         │      │
│    │    │   (마이크로프로그램 저장소)          │      │         │      │
│    │    │                                    │      │         │      │
│    │    │    주소    마이크로명령어            │      │         │      │
│    │    │    0x00    [제어신호들 | 다음주소]   │      │         │      │
│    │    │    0x01    [제어신호들 | 다음주소]   │      │         │      │
│    │    │    0x02    [제어신호들 | 다음주소]   │      │         │      │
│    │    │     ...                            │      │         │      │
│    │    └───────────────┬────────────────────┘      │         │      │
│    │                    │                            │         │      │
│    │    ┌───────────────┴───────────────┐           │         │      │
│    │    │                               │           │         │      │
│    │    ▼                               ▼           │         │      │
│    │  ┌─────────────┐           ┌────────────────┐  │         │      │
│    │  │ 제어 신호   │           │ Sequencer      │──┘         │      │
│    │  │ (출력)      │           │ (다음 주소)     │            │      │
│    │  └─────────────┘           └────────────────┘            │      │
│    │                                                            │      │
│    └────────────────────────────────────────────────────────────┘      │
│                                                                         │
└─────────────────────────────────────────────────────────────────────────┘

3.2 Control Store 구조¶

┌─────────────────────────────────────────────────────────────────────────┐
│                        Control Store (ROM)                               │
│                                                                         │
│    주소      마이크로명령어 (예: 32비트)                                 │
│    ┌──────┬─────────────────────────────────────────────────────────┐   │
│    │      │ ALU │Reg │Mem │Mem │ALU │Reg │PC  │ IR │다음│시퀀스     │   │
│    │ Addr │ Op  │Dst │Read│Wrt │Src │Wrt │Src │Wrt │주소│  제어     │   │
│    ├──────┼─────┼────┼────┼────┼────┼────┼────┼────┼────┼───────────┤   │
│    │ 0x00 │ 00  │ x  │ 1  │ 0  │ 0  │ 0  │ 0  │ 1  │0x01│ SEQ       │   │
│    │      │     │    │    │    │    │    │    │    │    │ (순차)    │   │
│    ├──────┼─────┼────┼────┼────┼────┼────┼────┼────┼────┼───────────┤   │
│    │ 0x01 │ 00  │ x  │ 0  │ 0  │ 0  │ 0  │ x  │ 0  │DISP│ DISPATCH  │   │
│    │      │     │    │    │    │    │    │    │    │    │ (분기)    │   │
│    ├──────┼─────┼────┼────┼────┼────┼────┼────┼────┼────┼───────────┤   │
│    │ 0x02 │ 00  │ 0  │ 0  │ 0  │ 1  │ 0  │ x  │ 0  │0x03│ SEQ       │   │
│    │      │     │    │    │    │    │    │    │    │    │ (lw/sw)   │   │
│    ├──────┼─────┼────┼────┼────┼────┼────┼────┼────┼────┼───────────┤   │
│    │ 0x03 │ xx  │ x  │ 1  │ 0  │ x  │ 0  │ x  │ 0  │0x04│ SEQ       │   │
│    │      │     │    │    │    │    │    │    │    │    │ (lw mem)  │   │
│    ├──────┼─────┼────┼────┼────┼────┼────┼────┼────┼────┼───────────┤   │
│    │ 0x04 │ xx  │ 0  │ 0  │ 0  │ x  │ 1  │ x  │ 0  │0x00│ FETCH     │   │
│    │      │     │    │    │    │    │    │    │    │    │ (lw wb)   │   │
│    ├──────┼─────┼────┼────┼────┼────┼────┼────┼────┼────┼───────────┤   │
│    │ ...  │     │    │    │    │    │    │    │    │    │           │   │
│    └──────┴─────┴────┴────┴────┴────┴────┴────┴────┴────┴───────────┘   │
│                                                                         │
└─────────────────────────────────────────────────────────────────────────┘

3.3 시퀀서 동작¶

┌─────────────────────────────────────────────────────────────────────────┐
│                         시퀀서 (Sequencer)                               │
│                                                                         │
│    현재 마이크로명령어의 시퀀스 제어 필드에 따라 다음 주소 결정          │
│                                                                         │
│    ┌────────────────────────────────────────────────────────────┐       │
│    │  시퀀스 제어  │              다음 주소 결정                 │       │
│    ├──────────────┼────────────────────────────────────────────┤       │
│    │    SEQ       │  MicroPC ← MicroPC + 1                     │       │
│    │   (순차)     │  다음 마이크로명령어로 진행                  │       │
│    ├──────────────┼────────────────────────────────────────────┤       │
│    │   BRANCH     │  MicroPC ← 마이크로명령어의 다음주소 필드   │       │
│    │   (분기)     │  조건 없이 지정된 주소로 점프               │       │
│    ├──────────────┼────────────────────────────────────────────┤       │
│    │   DISPATCH   │  MicroPC ← Mapping ROM[IR.Opcode]          │       │
│    │   (디스패치) │  명령어 종류에 따라 해당 루틴으로 분기       │       │
│    ├──────────────┼────────────────────────────────────────────┤       │
│    │   FETCH      │  MicroPC ← 0 (IF 상태로 복귀)              │       │
│    │   (페치)     │  다음 명령어 인출 시작                      │       │
│    └──────────────┴────────────────────────────────────────────┘       │
│                                                                         │
│    MUX를 통한 다음 주소 선택:                                           │
│                                                                         │
│    MicroPC+1 ────►┌───────┐                                            │
│    Branch Addr ──►│  MUX  │────► 다음 MicroPC                          │
│    Dispatch Addr─►│       │                                            │
│    0 (Fetch) ────►└───────┘                                            │
│                      ▲                                                  │
│                      │                                                  │
│              시퀀스 제어 신호                                            │
│                                                                         │
└─────────────────────────────────────────────────────────────────────────┘

3.4 마이크로프로그램 제어의 장단점¶

장점	단점
유연한 설계 (ROM만 수정)	하드와이어드보다 느림
복잡한 명령어 구현 용이	ROM 접근 지연
디버깅 용이	추가 하드웨어(Control Store) 필요
CISC 프로세서에 적합	전력 소모 증가
마이크로코드 업데이트 가능	면적 증가

3.5 실제 사용 예¶

┌─────────────────────────────────────────────────────────────────────────┐
│                    실제 프로세서의 마이크로코드 사용                      │
│                                                                         │
│    Intel x86 계열:                                                      │
│    ┌───────────────────────────────────────────────────────────────┐   │
│    │  - 복잡한 CISC 명령어를 마이크로코드로 구현                    │   │
│    │  - 단순 명령어는 하드와이어드로 빠르게 처리                    │   │
│    │  - 마이크로코드 업데이트로 보안 패치 적용 (예: Spectre/Meltdown)│   │
│    └───────────────────────────────────────────────────────────────┘   │
│                                                                         │
│    AMD 프로세서:                                                        │
│    ┌───────────────────────────────────────────────────────────────┐   │
│    │  - 유사하게 복잡한 명령어를 마이크로코드로 처리                 │   │
│    │  - BIOS/UEFI를 통해 마이크로코드 업데이트                      │   │
│    └───────────────────────────────────────────────────────────────┘   │
│                                                                         │
│    혼합 방식 (대부분의 현대 프로세서):                                   │
│    ┌───────────────────────────────────────────────────────────────┐   │
│    │  - 자주 사용되는 명령어: 하드와이어드 (고속)                    │   │
│    │  - 복잡한 명령어: 마이크로코드 (유연성)                        │   │
│    │  - 예: x86의 ADD는 하드와이어드, REP MOVS는 마이크로코드        │   │
│    └───────────────────────────────────────────────────────────────┘   │
│                                                                         │
└─────────────────────────────────────────────────────────────────────────┘

4. 제어 신호 생성¶

4.1 주요 제어 신호 목록¶

┌─────────────────────────────────────────────────────────────────────────┐
│                         주요 제어 신호                                   │
├──────────────┬──────────────────────────────────────────────────────────┤
│   제어 신호   │                        기능                              │
├──────────────┼──────────────────────────────────────────────────────────┤
│   RegDst     │ 쓰기 레지스터 선택 (rt=0, rd=1)                          │
├──────────────┼──────────────────────────────────────────────────────────┤
│   RegWrite   │ 레지스터 파일에 쓰기 허용                                 │
├──────────────┼──────────────────────────────────────────────────────────┤
│   ALUSrc     │ ALU 두 번째 입력 선택 (Register=0, Immediate=1)          │
├──────────────┼──────────────────────────────────────────────────────────┤
│   ALUOp      │ ALU 연산 종류 지정 (00=add, 01=sub, 10=R-type)           │
├──────────────┼──────────────────────────────────────────────────────────┤
│   MemRead    │ 메모리 읽기 활성화                                        │
├──────────────┼──────────────────────────────────────────────────────────┤
│   MemWrite   │ 메모리 쓰기 활성화                                        │
├──────────────┼──────────────────────────────────────────────────────────┤
│   MemtoReg   │ 레지스터에 쓸 데이터 선택 (ALU=0, Memory=1)              │
├──────────────┼──────────────────────────────────────────────────────────┤
│   PCSrc      │ PC 값 선택 (PC+4=0, Branch target=1)                     │
├──────────────┼──────────────────────────────────────────────────────────┤
│   Branch     │ 조건 분기 명령어 여부                                     │
├──────────────┼──────────────────────────────────────────────────────────┤
│   Jump       │ 무조건 점프 명령어 여부                                   │
└──────────────┴──────────────────────────────────────────────────────────┘

4.2 명령어별 제어 신호 값¶

┌─────────────────────────────────────────────────────────────────────────────────┐
│                          명령어별 제어 신호 진리표                               │
├──────────┬───────┬────────┬───────┬───────┬────────┬─────────┬────────┬────────┤
│ 명령어   │RegDst │ALUSrc  │MemtoReg│RegWrite│MemRead│MemWrite │Branch  │ALUOp   │
├──────────┼───────┼────────┼───────┼───────┼────────┼─────────┼────────┼────────┤
│ R-type   │   1   │   0    │   0   │   1   │   0    │    0    │   0    │  10    │
│ (add,sub)│       │        │       │       │        │         │        │        │
├──────────┼───────┼────────┼───────┼───────┼────────┼─────────┼────────┼────────┤
│   lw     │   0   │   1    │   1   │   1   │   1    │    0    │   0    │  00    │
├──────────┼───────┼────────┼───────┼───────┼────────┼─────────┼────────┼────────┤
│   sw     │   x   │   1    │   x   │   0   │   0    │    1    │   0    │  00    │
├──────────┼───────┼────────┼───────┼───────┼────────┼─────────┼────────┼────────┤
│   beq    │   x   │   0    │   x   │   0   │   0    │    0    │   1    │  01    │
├──────────┼───────┼────────┼───────┼───────┼────────┼─────────┼────────┼────────┤
│  addi    │   0   │   1    │   0   │   1   │   0    │    0    │   0    │  00    │
├──────────┼───────┼────────┼───────┼───────┼────────┼─────────┼────────┼────────┤
│    j     │   x   │   x    │   x   │   0   │   0    │    0    │   x    │  xx    │
└──────────┴───────┴────────┴───────┴───────┴────────┴─────────┴────────┴────────┘

x = don't care (어떤 값이든 상관없음)

4.3 제어 신호 생성 논리 회로¶

┌─────────────────────────────────────────────────────────────────────────┐
│                      제어 신호 생성 논리 회로                            │
│                                                                         │
│    Opcode [5:0]                                                         │
│       │                                                                 │
│       ├─────────────────────────────────────────────────────────────┐   │
│       │                                                             │   │
│       │   ┌─────────────────────────────────────────────────────┐   │   │
│       │   │                    디코더                            │   │   │
│       │   │                                                     │   │   │
│       │   │   Opcode    R-type  lw   sw   beq   addi   j       │   │   │
│       │   │   000000  ─────►                                    │   │   │
│       │   │   100011  ─────────►                                │   │   │
│       │   │   101011  ──────────────►                           │   │   │
│       │   │   000100  ───────────────────►                      │   │   │
│       │   │   001000  ────────────────────────►                 │   │   │
│       │   │   000010  ─────────────────────────────►            │   │   │
│       │   └─────────────────────────────────────────────────────┘   │   │
│       │           │       │      │      │       │       │           │   │
│       │           ▼       ▼      ▼      ▼       ▼       ▼           │   │
│       │                                                             │   │
│       │   RegDst  = R-type                                          │   │
│       │   ALUSrc  = lw | sw | addi                                  │   │
│       │   MemtoReg = lw                                             │   │
│       │   RegWrite = R-type | lw | addi                             │   │
│       │   MemRead  = lw                                             │   │
│       │   MemWrite = sw                                             │   │
│       │   Branch   = beq                                            │   │
│       │   ALUOp[1] = R-type                                         │   │
│       │   ALUOp[0] = beq                                            │   │
│       │   Jump     = j                                              │   │
│       │                                                             │   │
│       └─────────────────────────────────────────────────────────────┘   │
│                                                                         │
└─────────────────────────────────────────────────────────────────────────┘

4.4 타이밍 다이어그램¶

┌─────────────────────────────────────────────────────────────────────────┐
│                    LW 명령어 실행 타이밍 (단일 사이클)                    │
│                                                                         │
│   CLK    ────┐     ┌─────────────────────────────┐     ┌─────          │
│              │     │                             │     │               │
│              └─────┘                             └─────┘               │
│                                                                         │
│   PC     ════╪═════════════════════════════════════════╪═══            │
│          0x04│                                         │0x08           │
│                                                                         │
│   IR     ────╪═════════════════════════════════════════╪───            │
│              │          lw $t0, 4($s0)                 │               │
│                                                                         │
│   RegRead ───────────────────────────────────────────────────          │
│              │    ▼ $s0 값 읽기                                         │
│                                                                         │
│   ALU    ────────────────────────────────────────────────────          │
│                      │    ▼ $s0 + 4 계산                                │
│                                                                         │
│   MemRead ───────────────────────────────────────────────────          │
│                              │    ▼ Memory[$s0+4] 읽기                  │
│                                                                         │
│   RegWrite ──────────────────────────────────────────────────          │
│                                      │    ▼ $t0에 쓰기                  │
│                                                                         │
│          ├───IF───┼───ID───┼───EX───┼───MEM──┼───WB───┤                │
│                                                                         │
└─────────────────────────────────────────────────────────────────────────┘

5. 마이크로명령어¶

5.1 마이크로명령어 형식¶

┌─────────────────────────────────────────────────────────────────────────┐
│                        마이크로명령어 형식                               │
│                                                                         │
│    ┌────────────────────────────────────────────────────────────────┐  │
│    │                    수평 마이크로명령어                          │  │
│    │              (Horizontal Microinstruction)                     │  │
│    │                                                                │  │
│    │  ┌────┬────┬────┬────┬────┬────┬────┬────┬────┬────┬────────┐ │  │
│    │  │ALU │Reg │Reg │Mem │Mem │ALU │ALU │PC  │ IR │Seq │ Next   │ │  │
│    │  │Op  │Dst │Wrt │Rd  │Wrt │SrcA│SrcB│Wrt │Wrt │Ctl │ Addr   │ │  │
│    │  │4bit│1bit│1bit│1bit│1bit│1bit│2bit│1bit│1bit│2bit│ 6bit   │ │  │
│    │  └────┴────┴────┴────┴────┴────┴────┴────┴────┴────┴────────┘ │  │
│    │                                                                │  │
│    │  특징: 모든 제어 신호가 명시적으로 인코딩                       │  │
│    │       - 빠른 디코딩                                            │  │
│    │       - 넓은 비트 폭 (많은 ROM 필요)                           │  │
│    │       - 병렬 연산 가능                                         │  │
│    └────────────────────────────────────────────────────────────────┘  │
│                                                                         │
│    ┌────────────────────────────────────────────────────────────────┐  │
│    │                    수직 마이크로명령어                          │  │
│    │               (Vertical Microinstruction)                      │  │
│    │                                                                │  │
│    │  ┌────────────┬────────────┬────────────┬──────────────────┐  │  │
│    │  │  Operation │  Source    │Destination │  Next Address    │  │  │
│    │  │   (op)     │  (src)     │   (dst)    │                  │  │  │
│    │  │   4bit     │   4bit     │   4bit     │     6bit         │  │  │
│    │  └────────────┴────────────┴────────────┴──────────────────┘  │  │
│    │                                                                │  │
│    │  특징: 인코딩된 형식으로 제어 신호 표현                        │  │
│    │       - 좁은 비트 폭 (적은 ROM)                               │  │
│    │       - 추가 디코딩 필요 (느림)                               │  │
│    │       - 한 번에 하나의 연산                                   │  │
│    └────────────────────────────────────────────────────────────────┘  │
│                                                                         │
└─────────────────────────────────────────────────────────────────────────┘

5.2 마이크로명령어 예시 (LW 명령어)¶

┌─────────────────────────────────────────────────────────────────────────┐
│                    LW $t0, offset($s0) 마이크로프로그램                  │
│                                                                         │
│    주소    마이크로명령어                        설명                    │
│    ────────────────────────────────────────────────────────────────     │
│                                                                         │
│    0x00:  PCWrite=1, IRWrite=1, ALUSrcA=0,     // 명령어 인출 (IF)     │
│           ALUSrcB=01, ALUOp=00, MemRead=1,                              │
│           NextAddr=0x01, SeqCtl=SEQ                                     │
│                                                                         │
│    0x01:  ALUSrcA=0, ALUSrcB=11, ALUOp=00,     // 명령어 해독 (ID)     │
│           NextAddr=DISPATCH, SeqCtl=DISPATCH                            │
│                                                                         │
│    --- lw 명령어 디스패치 →                                             │
│                                                                         │
│    0x10:  ALUSrcA=1, ALUSrcB=10, ALUOp=00      // 주소 계산           │
│           NextAddr=0x11, SeqCtl=SEQ            // A = $s0 + offset     │
│                                                                         │
│    0x11:  MemRead=1                             // 메모리 읽기          │
│           NextAddr=0x12, SeqCtl=SEQ            // MDR ← Mem[A]         │
│                                                                         │
│    0x12:  RegDst=0, RegWrite=1, MemtoReg=1     // 쓰기 (WB)            │
│           NextAddr=0x00, SeqCtl=FETCH          // $t0 ← MDR            │
│                                                                         │
│    마이크로연산 순서:                                                    │
│    1. MAR ← PC; IR ← Mem[MAR]; PC ← PC + 4                             │
│    2. A ← Regs[$s0]                                                     │
│    3. ALUOut ← A + sign_extend(offset)                                 │
│    4. MDR ← Mem[ALUOut]                                                │
│    5. Regs[$t0] ← MDR                                                  │
│                                                                         │
└─────────────────────────────────────────────────────────────────────────┘

5.3 마이크로명령어 시퀀싱¶

┌─────────────────────────────────────────────────────────────────────────┐
│                      마이크로명령어 시퀀싱 예시                          │
│                                                                         │
│    시작                                                                 │
│      │                                                                  │
│      ▼                                                                  │
│    ┌────────┐                                                          │
│    │ 0x00   │  IF: 명령어 인출                                         │
│    │ (IF)   │  MAR←PC, IR←Mem[MAR], PC←PC+4                            │
│    └───┬────┘                                                          │
│        │ SEQ                                                           │
│        ▼                                                                │
│    ┌────────┐                                                          │
│    │ 0x01   │  ID: 명령어 해독, 레지스터 읽기                           │
│    │ (ID)   │  A←Regs[rs], B←Regs[rt]                                  │
│    └───┬────┘                                                          │
│        │ DISPATCH (opcode에 따라)                                      │
│        │                                                                │
│   ┌────┴────┬────────────┬────────────┬────────────┐                  │
│   │         │            │            │            │                   │
│   ▼         ▼            ▼            ▼            ▼                   │
│ ┌──────┐ ┌──────┐    ┌──────┐    ┌──────┐    ┌──────┐                 │
│ │ 0x10 │ │ 0x20 │    │ 0x30 │    │ 0x40 │    │ 0x50 │                 │
│ │ lw   │ │ sw   │    │R-type│    │ beq  │    │  j   │                 │
│ └──┬───┘ └──┬───┘    └──┬───┘    └──┬───┘    └──┬───┘                 │
│    │        │           │           │           │                      │
│    ▼        ▼           ▼           │           │                      │
│ ┌──────┐ ┌──────┐    ┌──────┐      │           │                      │
│ │ 0x11 │ │ 0x21 │    │ 0x31 │      │           │                      │
│ │MemRd │ │MemWr │    │ R-WB │      │           │                      │
│ └──┬───┘ └──┬───┘    └──┬───┘      │           │                      │
│    │        │           │           │           │                      │
│    ▼        │           │           │           │                      │
│ ┌──────┐    │           │           │           │                      │
│ │ 0x12 │    │           │           │           │                      │
│ │ LW-WB│    │           │           │           │                      │
│ └──┬───┘    │           │           │           │                      │
│    │        │           │           │           │                      │
│    └────────┴───────────┴───────────┴───────────┴───►(0x00 IF로 복귀)  │
│                          FETCH                                          │
└─────────────────────────────────────────────────────────────────────────┘

5.4 수평 vs 수직 마이크로명령어 비교¶

특성	수평 (Horizontal)	수직 (Vertical)
비트 폭	넓음 (50-100비트)	좁음 (16-32비트)
디코딩	불필요/최소	추가 디코딩 필요
속도	빠름	느림
병렬성	높음 (동시 제어)	낮음 (순차적)
ROM 크기	큼	작음
유연성	높음	중간

5.5 나노프로그래밍¶

┌─────────────────────────────────────────────────────────────────────────┐
│                       나노프로그래밍 (Nanoprogramming)                   │
│                                                                         │
│    2단계 제어 저장소를 사용하여 Control Store 크기 최적화                │
│                                                                         │
│    ┌─────────────────────────────────────────────────────────────────┐ │
│    │                                                                 │ │
│    │   MicroPC ───►┌─────────────────────┐                          │ │
│    │               │   Control Store     │                          │ │
│    │               │   (마이크로 ROM)     │                          │ │
│    │               │                     │                          │ │
│    │               │   ┌──────┬────────┐ │                          │ │
│    │               │   │NanoPC│NextAddr│ │──► 시퀀스 제어           │ │
│    │               │   └──┬───┴────────┘ │                          │ │
│    │               └──────┼──────────────┘                          │ │
│    │                      │                                          │ │
│    │                      ▼                                          │ │
│    │               ┌─────────────────────┐                          │ │
│    │               │   Nano Store        │                          │ │
│    │               │   (나노 ROM)         │                          │ │
│    │               │                     │                          │ │
│    │               │   실제 제어 신호    │──► 제어 신호 출력         │ │
│    │               │   인코딩            │                          │ │
│    │               └─────────────────────┘                          │ │
│    │                                                                 │ │
│    └─────────────────────────────────────────────────────────────────┘ │
│                                                                         │
│    장점: 반복되는 제어 신호 패턴을 공유하여 ROM 절약                     │
│    단점: 추가 접근 지연                                                 │
│                                                                         │
└─────────────────────────────────────────────────────────────────────────┘

6. 연습 문제¶

기초 문제¶

제어장치의 주요 역할 3가지를 설명하시오.
하드와이어드 제어와 마이크로프로그램 제어의 차이점을 비교하시오.
다음 제어 신호의 역할을 설명하시오:
(a) RegWrite
(b) ALUSrc
(c) MemtoReg

제어 신호 분석 문제¶

다음 MIPS 명령어 실행 시 각 제어 신호의 값을 결정하시오:

ADD $t0, $t1, $t2

RegDst = ?
ALUSrc = ?
MemtoReg = ?
RegWrite = ?
MemRead = ?
MemWrite = ?
Branch = ?
ALUOp = ?
SW $t0, 100($s0) 명령어의 제어 신호를 모두 결정하시오.

마이크로프로그램 문제¶

마이크로프로그램 제어에서 시퀀서의 역할을 설명하시오.
수평 마이크로명령어와 수직 마이크로명령어의 장단점을 비교하시오.
BEQ $t0, $t1, label 명령어의 마이크로명령어 시퀀스를 작성하시오.

심화 문제¶

다음 상황에서 어떤 제어 방식(하드와이어드/마이크로프로그램)이 더 적합한지 설명하시오:
(a) 단순한 RISC 프로세서 설계
(b) 복잡한 CISC 프로세서 설계
(c) 마이크로코드 업데이트가 필요한 경우
다중 사이클 CPU의 FSM(유한 상태 기계)에서 lw 명령어가 거치는 모든 상태를 나열하고, 각 상태에서 활성화되는 제어 신호를 설명하시오.

정답

1. 제어장치의 주요 역할: - 명령어 해독: IR의 opcode를 분석하여 명령어 종류 파악 - 타이밍 생성: 각 작업의 실행 순서와 시점 결정 - 제어 신호 생성: 데이터패스의 각 구성요소를 제어하는 신호 출력 2. 비교: - 하드와이어드: 논리 회로로 직접 구현, 빠르지만 수정 어려움 - 마이크로프로그램: ROM에 저장된 프로그램 실행, 유연하지만 느림 3. 제어 신호 역할: - (a) RegWrite: 레지스터 파일에 데이터 쓰기 허용 - (b) ALUSrc: ALU의 두 번째 입력 소스 선택 (0=레지스터, 1=즉시값) - (c) MemtoReg: 레지스터에 쓸 데이터 선택 (0=ALU, 1=메모리) 4. ADD 명령어 제어 신호: - RegDst = 1 (rd 사용) - ALUSrc = 0 (레지스터) - MemtoReg = 0 (ALU 결과) - RegWrite = 1 - MemRead = 0 - MemWrite = 0 - Branch = 0 - ALUOp = 10 (R-type) 5. SW 명령어 제어 신호: - RegDst = x (don't care) - ALUSrc = 1 (즉시값 100) - MemtoReg = x - RegWrite = 0 - MemRead = 0 - MemWrite = 1 - Branch = 0 - ALUOp = 00 (add) 6. 시퀀서 역할: - 현재 마이크로명령어의 시퀀스 제어 필드를 해석 - 다음 마이크로명령어 주소 결정 (순차, 분기, 디스패치, 페치) - MicroPC 값 업데이트 7. 수평 vs 수직: - 수평: 빠른 실행, 병렬 제어 가능, 넓은 비트폭, 큰 ROM - 수직: 좁은 비트폭, 작은 ROM, 추가 디코딩 필요, 느림 8. BEQ 마이크로명령어: - IF: MAR←PC, IR←Mem[MAR], PC←PC+4 - ID: A←Regs[$t0], B←Regs[$t1], ALUOut←PC+(offset<<2) - EX: if (A==B) PC←ALUOut → 0x00 (IF로 복귀) 9. - (a) RISC: 하드와이어드 (명령어가 단순하고 속도 중요) - (b) CISC: 마이크로프로그램 (복잡한 명령어 구현 용이) - (c) 업데이트 필요: 마이크로프로그램 (ROM만 수정) 10. lw 명령어 상태: - State 0 (IF): MemRead=1, IRWrite=1, PCWrite=1 - State 1 (ID): (레지스터 읽기) - State 2 (MemAddr): ALUSrcA=1, ALUSrcB=10, ALUOp=00 - State 3 (MemRead): MemRead=1 - State 4 (LW-WB): RegDst=0, MemtoReg=1, RegWrite=1

다음 단계¶

09_Instruction_Set_Architecture.md - CISC vs RISC, 주소 지정 방식

참고 자료¶

Computer Organization and Design (Patterson & Hennessy)
Computer Architecture: A Quantitative Approach (Hennessy & Patterson)
MIPS Control Unit Implementation
Digital Design and Computer Architecture (Harris & Harris)