🪜 Computer System : 4. 프로세서 구조_part2

SEQ의 구현

SEQ는 Y86-64 명령어들을 한 클럭 사이클에 하나씩, 순서대로 처리하는 CPU 설계 모델로 파이프라인도 병렬 처리도 존재하지 않기 때문에 클럭 속도가 매우 느리다.

이렇듯 매우 느리지만 배우기 쉬운 구조이기 때문에 이후에 SEQ를 바탕으로 파이프라인 구조를 설계하는데에 도움을 줄 수 있다.

특징	SEQ	Pipeline
처리 방식	순차적	병렬적
한 사이클에 실행되는 명령어 수	1개	최대 N개 (스테이지 수만큼)
설계 복잡도	매우 쉬움 😊	복잡함 😵 (해저드 처리 등)
성능	낮음	높음

SEQ의 순차적 실행

⁉️ 그래서 SEQ는 한 사이클에 어떤 작업을 처리하길래 오래걸리는가?
SEQ는 한 사이클에 아래 단계를 모두 처리하려고 하다 보니 클럭 주기가 길어진다.

• 명령어 인출 (IF,fetch)
• 디코딩 (ID,decode)
• 실행 (EX,execution)
• 메모리 접근 (MEM,memory)
• 결과 저장 (WB,writeback)
• PC 갱신

각 단계를 자세히 살펴보려고 한다.

1️⃣ 명령어 인출(Fetch)

프로그램 카운터를 이용해서 인스트럭션들을 메모리에서 읽고, 필요한 정보를 저장하고, 다음 명령어 주소를 계산한다.

• PC를 이용해서 메모리에서 인스트럭션들을 읽는다
  : icdoe, ifun을 추출
• 레지스터 또는 상수값이 필요한 인스트럭션의 경우 레지스터 지시자 또는 상수값 또한 추출
  : rA, rB, ValC 추출
• 다음 인스트럭션 주소를 계산한다.
  : valP = PC + 명령어 길이

🔥 이때 ! valP를 단순히 PC + 인스트럭션 길이가 될 수 있는 이유**

✅ "Y86-64 명령어는 메모리에서 연속된 바이트로 저장된다"
즉, 명령어는 항상 PC부터 시작해서, 그 다음 바이트, 또 그 다음 바이트... 이렇게 연속적으로 저장된다. 그렇기 때문에 명령어의 총 길이를 알면 다음 명령어의 시작 위치는
👉 PC + 명령어 길이 → valP 인 것이다.

2️⃣ 해독 (Decode)

명령어에 들어있는 rA, rB를 이용해 R[rA] → valA, R[rB] → valB 로 읽어옴

• 레지스터의 값을 읽어온다
  : valA, valB

3️⃣ 실행 (Execution)

다양한 연산을 수행하거나, 조건코드들을 설정한다

• 인스트럭션이 지시하는 연산을 수행한다
  : ALU가 ifun 값에 따라 연산을 수행한다
  👉 valE = Execute 단계(ALU)에서 계산된 결과값
  👉 set CC = 연산 후에 조건코드의 업데이트 여부를 결정하는 제어 신호

4️⃣ 메모리

필요시에 메모리에 접근한다

• 메모리에 데이터를 쓰거나 데이터를 읽어올 수 있다
  👉 valM = 읽어 온 데이터 값

5️⃣ 재기록(write Back)

계산 결과를 레지스터에 저장한다.

• 두 계산 결과를 레지스터 파일에 기록한다

6️⃣ PC 갱신

다음 인스트럭션의 주소로 PC를 설정한다

• 다음 인스트럭션의 주소를 설정한다
  : Fetch 단계에서 계산되었던 valP 값을 PC에 할당한다.
  👉 즉, PC값이 갱신되는타이밍은 명령어 실행이 끝난 다음이다.

---

☑️ 정리

프로세서는 위와 같은 단계들을 무한히 반복하며 한 개의 인스트럭션을 실행하는데에 놀라운 양의 작업을 요구한다.
다만, 전체적인 흐름은 모든 인스트럭션들이 유사하다는 것을 알 수 있다.

위와 같은 표 처럼 여러 인스트럭션를 일반적인 프레임워크 내에 맞춰 넣기위해 필요한 계산들을 찾는 것이 어려운 부분이다. 또한 이러한 표들은 하드웨어에 직접 매칭될 수 있는 형태로 그려진다. 다만 이해를 도울 뿐 실제 회로로 만들때는 대부분 병렬처리가 가능하므로 엄격하게 순차를 지킬 필요는 없다.

🧪 SEQ : push&pop

📌 Instruction: pushq rA

rA의 값을 스택에 저장하는 인스트럭션의 SEQ

⛓️ Pipeline Stages

Stage	Operation	Explanation
Fetch	icode:ifun ← M1[PC]	Fetch instruction code
	rA:rB ← M1[PC+1]	Get register specifier
	valP ← PC + 2	Next instruction address
Decode	valA ← R[rA]	Value to push
	valB ← R[%rsp]	Current stack pointer
Execute	valE ← valB + (-8)	Allocate space on stack
Memory	M8[valE] ← valA	Store rA's value to new stack slot
Write Back	R[%rsp] ← valE	Update stack pointer
PC Update	PC ← valP	Move to next instruction

---

📌 Instruction: popq rA

스택에서 값을 꺼내서 rA에 저장하는 인스트럭션의 SEQ

⛓️ Pipeline Stages

Stage	Operation	Explanation
Fetch	icode:ifun ← M1[PC]	Fetch instruction code
	rA:rB ← M1[PC+1]	Get register specifier
	valP ← PC + 2	Next instruction address
Decode	valA ← R[%rsp]	Current top of stack address
	valB ← R[%rsp]	For computing new %rsp
Execute	valE ← valB + 8	Reclaim space on stack
Memory	valM ← M8[valA]	Load value from top of stack
Write Back	R[rA] ← valM	Store popped value to rA
	R[%rsp] ← valE	Update stack pointer
PC Update	PC ← valP	Move to next instruction

🔶 SEQ 인스트럭션 마무리

위에서 본 것 처럼 우리는 이제 Y86-64의 모든 인스트럭션을 처리할 수 있는 크게 6가지 단계의 통일된 프레임워크를 만들었다. 이제 우리가 이어서 할 내용은 이러한 단계들을 실제 구현하는 하드웨어를 설계하고 이들을 서로 연결하는 것이다.

🛠️ SEQ 하드웨어 구조

다음 그림은 Y86-64의 모든 인스트럭션을 순차적으로 수행할 수 있는 하드웨어 구조의 추상적인 관점이다.

⚙️ 하드웨어 유닛

☑️ 선입

• 인스트럭션 메모리 : 명령어 읽기
• PC 가산기 : 증가된 프로그램 카운터를 계산

☑️ 해독

• 두 개의 읽기 포트 : 레지스터 값 읽음

☑️ 실행

• ALU : 정해진 연산을 수행 (스택 포인터 계산, 유효 주소 계산 등)
• CC 조건코드 레지스터 : 세개의 조건코드 비트를 저장

☑️ 메모리

• 데이터 메모리 : 메모리 인스트럭션 실행 시 메모리 워드를 읽거나 씀

☑️ 재기록

• E포트 : ALU에 의해 계산 된 값 기록
• 포트M : 데이터 메모리에서 읽어온 값을 기록

☑️ PC 갱신

• 새로운 PC값 : valP, valM, call이나 jump 인스트럭션에 의한 주소 등

⁉️ 이때, 선입 단계에 있는 인스트럭션 메모리와 메모리 단계에 있는 데이터 메모리는 같은 RAM이다.
그저, 다른 목적과 다른 단계에서 사용하겠다는 의미를 위해 이름을 다르게 명명해서 사용하는 것이다.

🔗 하드웨어 & 인스트럭션

결국 위에서 했던 모든 계산들(ex. push/pop)을 방금 본 실제 하드웨어로 옮기기 위해 우린 제어 로직을 만들어야 한다.
다시말해 ALU를 켤지 말지, 메모리에 접근할지 말지, 어떤 레지스터를 읽고 쓸지 등의 상세 설계를 만들어야 하는 것이다.

⏱️ SEQ의 타이밍

위에서 push/pop의 인스트럭션이 처리되는 표를 봤고, 하드웨어의 구조도 봤다.
표에서는 인스트럭션이 순차적으로 시행된다는 것을 보았지만 실제 하드웨어는 그런 것 없이 전부 한번에 처리한다.
즉, 하드웨어는 트리거가 되는 특정 클럭 변화가 생기면 모든 회로에 순식간에 신호가 퍼지고 인스트럭션을 처리한다.

그렇다면 이제는 하드웨어가 이러한 처리를 어떻게 하는지 알아보려고 한다.

SEQ의 구성요소

SEQ는 조합논리회로와 두 가지 형태의 메모리 장치로 이루어진다.

🔶 조합논리회로

순차처리나 제어를 필요로 하지 않으며 입력이 바뀔때마다 논리 게이트의 네트워크를 통해 저절로 전파된다.
즉, 클럭이나 타이밍 신호 없이 작동한다.

🔶 첫번째 메모리 장치 : 랜덤 엑세스 메모리(RAM)

레지스터 파일, 인스트럭션 메모리, 데이터 메모리가 포함된다.

이때, 인스트럭션 메모리는 읽기 전용이기 때문에 원하는 순간마다 결과 값이 바로 나온다고 생각해도 무방하다.
그렇기 때문에 조합논리처럼 고려해도 된다.

🔶 두번째 메모리 장치 : 레지스터

프로그램 카운터, 조건코드 레지스터가 포함된다.

🔹 프로그램 카운터, 조건코드 레지스터, 데이터 메모리, 레지스터 파일

SEQ 구성요소들 중에서 위의 4가지는 인스트럭션 메모리, 조합논리회로와 달리 클럭 신호에 의해서 제어된다.
이처럼 레지스터들과 메모리에 클럭을 공급하는 것은, 우리가 설계한 프로세서에서 여러 동작들을 순서대로 제어하기 위해 필요한 모든 것이다.

⛓️ SEQ 구조에서의 핵심 원칙: No Reading Back

🧭 No Reading Back

No Reading Back Principle
→ "한 인스트럭션이 자신이 갱신한 상태값을 다시 읽는 동작은 없어야 한다."

✅ 이 원칙이 필요한 이유

• 하나의 클럭 사이클 동안 상태(state)는 클럭 상승 시점에 한 번만 업데이트됨.
• 따라서 인스트럭션 처리 중에 방금 갱신한 값을 다시 참조할 수 없음.
• 이를 위반하면 순차적인 동작 보장이 어려워짐 → 디자인 복잡성 증가 + 타이밍 이슈 발생

---

📦 예시 1: pushq 명령어 처리

❌ 잘못된 설계

1. %rsp를 8만큼 감소
2. 업데이트된 %rsp 값을 다시 읽어서 메모리에 저장

→ 이는 상태값을 갱신한 후 다시 읽는 구조이므로 원칙 위반!

✅ 올바른 SEQ 구현

• 감소된 %rsp - 8 값을 valE로 생성
• valE를:
  • 레지스터 쓰기 데이터로 사용
  • 메모리 쓰기 주소로도 사용

→ 갱신한 값을 사용하는 것이 아니고 valE라는 상수같은 생성값을 사용하는 것임
→ 동일한 valE를 동시에 사용하여 메모리 및 레지스터에 쓰기 가능
→ 클럭 상승 시점에 모든 쓰기 동작이 정렬됨

---

📦 예시 2: Condition Codes (ZF, SF, OF)

🔄 사용 흐름

• addq, subq 등은 Condition Codes를 설정
• jXX, cmovXX 등은 Condition Codes를 읽음

✅ 원칙 준수

• 어떤 명령어도 조건 코드를 설정하고 곧바로 읽지 않음
• 조건 코드는 항상 다음 사이클에 읽음
  • → 즉, 읽기 전에 반드시 한 사이클의 지연이 존재

---

🔍 SEQ에서 명령어 처리 흐름

🌀 사이클별 동작

▶ Cycle 3 시작 시

• %rbx는 아직 0x100 상태 (addq 결과 반영 전)
• 조합논리는 아직 반응 전 (하얀 박스)

▶ Cycle 3 종료 시

• %rbx ← 0x300 (addq 수행 결과)
• Condition Code ← 000 (ZF=0)
• PC ← 0x016

▶ Cycle 4 종료 시

• je 수행: ZF=0 → 분기 실패 → PC ← 0x01f
• 조합논리가 분기 실패 반영 완료

---

🧠 요약

• SEQ는 각 상태 요소(레지스터, PC, 메모리, CC 등) 를 오직 한 번만 업데이트함
• 모든 업데이트는 클럭 상승 순간 동시에 발생
• 이 원칙 덕분에 간단하고 안정적인 순차 처리 구조 설계 가능!

🪜 SEQ 단계의 구현

모든 인스트럭션을 하드웨어로 옮기기 위해 우린 제어로직을 만들어야 한다고 했다.
그리고 그러한 제어로직 블록을 위한 HCL(Hardware Control Language) 작성 방법을 정리했다.

위 사진은 앞으로 볼 HCL 문장에서 사용할 상수 값으로 각각
인스트럭션 인코딩, 함수코드, 레지스터ID, ALU연산, 상태코드 등을 나타낸다.

🔹 Fetch(선입 단계)

단계)

bool need_regids =
icode in { IRRMOVQ, IOPQ, IPUSHQ, IPOPQ,
IIRMOVQ, IRMMOVQ, IMRMOVQ };

🧠 핵심

• Instruction Memory 를 포함하고 있다.

  • PC를 시작 주소로 하여 10바이트를 읽는다
  • 첫 번째 바이트 (Byte 0): Instruction Byte
    • Split 블록에서 두 개의 4-bit 값으로 분할:
      • icode: Instruction Code = 명령어의 종류
      • ifun: Function Code = 명령어의 세부 동작

• Align 를 포함하고 있다.

  • 1-9 번째 바이트 (Byte 0을 제외한 나머지):
    • 레지스터 필드와 상수 워드에 대한 처리 작업을 수행한다.

• PC increment 를 포함하고 있다.

  • 현재의 pc값, need_regids 값 r, need_valC 값으로 valP 만든다.

🔎 예외 처리

• imem_error:
  • 유효하지 않은 주소일 경우 imem_error 신호가 활성화된다.
  • 이 경우 icode, ifun은 nop 명령어 값(0) 으로 대체된다.

✅ 결과

• Control Logic은 icode 값을 기반으로 3개의 1비트 제어 신호를 계산한다.
  (이 제어 신호들은 점선으로 표현됨 — 도식 기준)
  • instr_valid : 이 바이트는 합법적인 Y86-64 인스트럭션인가?
  • need_regids : 이 인스트럭션은 레지스터 지정 바이트를 포함하는가?
  • need_valC : 이 인스트럭션은 상수 워드를 포함하는가?

---

🔹 Decode and Write-Back (해독과 재기록 단계)

word srcA = [
icode in { IRRMOVQ, IRMMOVQ, IOPQ, IPUSHQ } : rA;
icode in { IPOPQ, IRET } : RRSP;
1 : RNONE; # Don’t need register
];

word dstE = [
icode in { IRRMOVQ } : rB;
icode in { IIRMOVQ, IOPQ} : rB;
icode in { IPUSHQ, IPOPQ, ICALL, IRET } : RRSP;
1 : RNONE; # Don’t write any register
];

두 단계 모두 레지스터 파일에 접근하기 때문에 함께 설명한다.

🧠 핵심

• 인스트럭션 코드, 레지스터 지정자 rA, rB, 실행 단계에서 계산된 조건신호 Cnd에 기초하여 4개의 레지스터ID를 구성
• 두 개의 읽기 포트와 쓰기 포트를 갖는다.
  • 읽기 포트(srcA, srcB =valA, valB)
  • 쓰기 포트(dstM, dstE =valM, valE)
    

---

🔹 Execute(실행 단계)

word aluA = [
icode in { IRRMOVQ, IOPQ } : valA;
icode in { IIRMOVQ, IRMMOVQ, IMRMOVQ } : valC;
icode in { ICALL, IPUSHQ } : -8;
icode in { IRET, IPOPQ } : 8;
# Other instructions don’t need ALU
];

🧠 핵심

• 산술/논리 유닛 ALU를 포함하고 있다.
  • aluA, aluB, alufun 신호의 설정에 따라 실행된다.
    
• CC(조건코드 레지스터) 를 포함하고 있다.
  • ALU에서 계산된 결과로부터 조건코드 (ZF, SF, OF 등) 를 받아서 저장하는 레지스터
  • Set CC는 어떤 명령어(icode)일 때만 조건코드를 갱신할지를 판단함
  • 이후 조건부 분기 판단용 cond 블록에서 이 CC 값을 읽어서 조건 분기 수행

---

🔹 Memory(메모리 단계)

word mem_addr = [
icode in { IRMMOVQ, IPUSHQ, ICALL, IMRMOVQ } : valE;
icode in { IPOPQ, IRET } : valA;
# Other instructions don’t need address
];

bool mem_read = icode in { IMRMOVQ, IPOPQ, IRET };

🧠 핵심

- 메모리는 항상 valE 또는 valA 중 하나를 주소로 사용한다.

• 읽기/쓰기 여부는 icode에 따라 달라진다.
• 읽기 결과는 valM으로 저장된다.

---

🔹 PC Update(PC 갱신 단계)

word new_pc = [
# Call. Use instruction constant
icode == ICALL : valC;
# Taken branch. Use instruction constant
icode == IJXX && Cnd : valC;
# Completion of RET instruction. Use value from stack
icode == IRET : valM;
# Default: Use incremented PC
1 : valP;
];                            

🧠 핵심

-SEQ의 최종단계로프로그램 카운터 값을 생성한다.

• 인스트럭션 타입과 분기를 택할 지 여부에 따라 valC/valM/valP 가 될 수 있다.

---

🔥 SEQ의 한계와 파이프라이닝의 필요성

✅ SEQ의 장점

• Y86-64 프로세서의 모든 명령어 실행 과정을 하나의 통일된 흐름(uniform flow) 으로 구성
• 소수의 하드웨어 유닛과 하나의 클럭 신호만으로 전체 명령어 처리 가능
• 제어 논리는 instruction type과 분기 조건에 따라 올바른 제어 신호를 생성해야 한다.

❌ SEQ의 한계: 느린 클럭 속도

• 모든 동작을 하나의 클럭 사이클 내에서 완료해야 함
  • 즉, 모든 연산이 직렬로 진행됨
  • 따라서 클럭 사이클이 매우 느리게 동작해야 함

📉 예시: ret 명령어

ret 명령어를 실행하려면 다음의 동작이 모두 하나의 사이클 내에서 수행되어야 함:

1. 명령어 메모리에서 ret 명령어 읽기
2. 스택 포인터(%rsp)를 레지스터 파일에서 읽기
3. ALU를 통해 %rsp + 8 계산
4. 새로운 %rsp 값을 주소로 메모리에서 리턴 주소를 읽기
5. 읽은 리턴 주소를 프로그램 카운터(PC)에 설정

⏱ 위 과정이 모두 한 클럭 상승 시점 내에 완료되어야 하므로, 클럭을 매우 느리게 해야 함

---

🛠 비효율적인 자원 사용

• 각 하드웨어 유닛(ALU, 메모리 등)은 한 사이클 내의 일부 시간만 사용됨
• 결과적으로 자원 활용도는 낮고, 에너지/속도 면에서 비효율적임

---

🚀 해결책: 파이프라이닝(Pipelining)

• 하드웨어 자원을 여러 명령어가 동시에 사용할 수 있도록 분할 실행
• 각 명령어는 여러 사이클에 걸쳐 다른 스테이지를 수행
• 결과적으로 성능 향상 및 클럭 속도 증가 가능

---