Outline

목표

upgrade single cycle CPU into a multicycle CPU
- Defining additional control signals for multi-cycle architecture
- Building an FSM to control multi-cycle execution
- Supporting jal and jr

1. Design

1. additional control signals

State Control

IRWrite: Instruction Register에 메모리로부터 읽은 명령어를 저장할지 결정
- PCWrite: Program Counter 업데이트 여부를 결정
- PCWriteCond: Branch 명령어에서 조건이 만족될 때 PC 업데이트 여부를 결정

Memory Access Control
- IorD: Memory 주소로 PC를 사용할지(0) ALUOut을 사용할지(1) 결정
ALU Input Control

ALUSrcA[1:0]: ALU의 첫 번째 입력 선택
- 00: PC
- 01: Register A
- 10: Don't care
- 11: Don't care
ALUSrcB[1:0]: ALU의 두 번째 입력 선택
- 00: Register B
- 01: 4 (PC increment)
- 10: Sign-extended immediate
- 11: Shifted sign-extended immediate

PC Source Control

PCSource[1:0]: 다음 PC 값 선택
- 00: ALU Result
- 01: ALUOut
- 10: Jump Target ({PC[31:28], immediate[25:0], 2'b00})
- 11: Register A (JR instruction)

SavePC: JAL 명령어에서 return address를 $ra에 저장할지 결정
jal_save: JAL 명령어 처리를 위한 내부 상태 저장

2. FSM

S0_IFETCH:

동작: IR ← Memory[PC], PC ← PC + 4
전이: 무조건 S1_IDECODE로

S1_IDECODE:

동작: A ← Reg[rs], B ← Reg[rt]
전이 조건: opcode에 따라 다른 상태로
- R-type → S2_RTYPE_EXEC
- I-type → S2_ITYPE_EXEC
- BEQ/BNE → S2_BRANCH_COMP
- JAL → S2_JAL_SAVE
- JR → S2_JR
- LW → S2_LW_ADDR
- SW → S2_SW_ADDR

각 실행 상태:

S2_RTYPE_EXEC: ALUOut ← ALU(A,B)
S2_ITYPE_EXEC: ALUOut ← ALU(A,imm)
S2_BRANCH_COMP: ALUOut ← ALU(A,B) (EQ/NEQ 비교)
S2_JAL_SAVE: Reg[31] ← PC + 4
S2_JR: PC ← A

메모리 접근 상태:

S2_LW_ADDR: ALUOut ← A + SignExt(imm)
S3_LW_MEM: MDR ← Memory[ALUOut]
S2_SW_ADDR: ALUOut ← A + SignExt(imm)
S3_SW_MEM: Memory[ALUOut] ← B

Write-Back 상태:

S3_RTYPE_WB: Reg[rd] ← ALUOut
S3_ITYPE_WB: Reg[rt] ← ALUOut
S4_LW_WB: Reg[rt] ← MDR

2. Implement

1. cpp에서 구현

• CPU.cpp

CPU 초기화

void CPU::init(string inst_file) {
    rf.init(false);
    mem.load(inst_file);
    PC = 0;
    state = S0_IFETCH;
    status = CONTINUE;
}

기본 생성자는 비어있음
init 함수는 CPU의 초기 상태를 설정:
- rf.init(false): 레지스터 파일 초기화
- mem.load(inst_file): 메모리에 명령어 파일 로드
- PC = 0: 프로그램 카운터 초기화
- state = S0_IFETCH: 초기 상태를 명령어 페치로 설정
- status = CONTINUE: CPU 실행 상태를 정상 실행으로 설정

Instruction Fetch

case S0_IFETCH: {
    mem.memAccess(PC, &IR, 0, 1, 0); // MemRead
    if (status != CONTINUE) return 0;
    PC += 4;
    state = ctrl.nextState(state, parsed_inst);
    break;
}

mem.memAccess: 메모리에서 명령어 읽기
- PC: 읽을 메모리 주소
- &IR: 읽은 데이터를 저장할 명령어 레지스터
- 0: 쓰기 데이터 (읽기만 하므로 0)
- 1: MemRead 신호
- 0: MemWrite 신호
PC를 4만큼 증가 (다음 명령어 주소)
다음 상태 결정

Instruction Decode

case S1_IDECODE: {
    ctrl.splitInst(IR, &parsed_inst);
    uint32_t rs_data, rt_data;
    rf.read(parsed_inst.rs, parsed_inst.rt, &rs_data, &rt_data);
    A = rs_data;
    B = rt_data;
    state = ctrl.nextState(state, parsed_inst);
    break;
}

ctrl.splitInst: 명령어(IR)를 각 필드로 분석
rf.read: 레지스터 파일에서 rs와 rt 레지스터 값을 읽음
A와 B 레지스터에 읽은 값 저장
다음 상태 결정

R-type Instruction 실행

case S2_RTYPE_EXEC: {
    uint32_t result;
    alu.compute(A, B, parsed_inst.shamt, controls.ALUOp, &result);
    ALUOut = result;
    state = ctrl.nextState(state, parsed_inst);
    break;
}

alu.compute: ALU 연산 수행
- A: 첫 번째 피연산자
- B: 두 번째 피연산자
- shamt: shift amount (시프트 연산에 사용)
- ALUOp: 수행할 연산 종류
- result: 연산 결과
ALUOut에 결과 저장
다음 상태 결정

R-type Instruction 쓰기

    case S3_RTYPE_WB: {
        uint32_t dst = parsed_inst.rd;
        rf.write(dst, ALUOut, controls.RegWrite);
        state = S0_IFETCH;
        break;
    }

rd 레지스터를 목적지로 설정
rf.write: 레지스터 파일에 결과 쓰기
- dst: 목적지 레지스터 번호
- ALUOut: 쓸 데이터
- RegWrite: 쓰기 제어 신호
다음 상태를 IFETCH로 설정

I-type Instruction 실행

    case S2_ITYPE_EXEC: {
        uint32_t imm_ext;
        ctrl.signExtend(parsed_inst.immi, controls.SignExtend, &imm_ext);
        uint32_t result;
        alu.compute(A, imm_ext, 0, controls.ALUOp, &result);
        ALUOut = result;
        state = ctrl.nextState(state, parsed_inst);
        break;
    }

ctrl.signExtend: immediate 값의 부호 확장
ALU 연산 수행 (A와 확장된 immediate 값 사용)
결과를 ALUOut에 저장

I-type Instruction 쓰기

    case S3_ITYPE_WB: {
        rf.write(parsed_inst.rt, ALUOut, controls.RegWrite);
        state = S0_IFETCH;
        break;
    }

rt 레지스터에 결과 쓰기
IFETCH 상태로 돌아가기

Load/Store 주소 계산

    case S2_LW_ADDR:
    case S2_SW_ADDR: {
        uint32_t imm_ext;
        ctrl.signExtend(parsed_inst.immi, 1, &imm_ext);
        uint32_t result;
        alu.compute(A, imm_ext, 0, controls.ALUOp, &result);
        ALUOut = result;
        state = ctrl.nextState(state, parsed_inst);
        break;
    }

Load와 Store 명령어의 메모리 주소 계산
immediate 값을 부호 확장
베이스 주소(A)와 오프셋(imm_ext)을 더해 최종 주소 계산

Load memory access

    case S3_LW_MEM: {
        cerr << "[CPU] ALUOut (byte addr): " << hex << ALUOut << endl;
        mem.memAccess(ALUOut, &MDR, 0, controls.MemRead, 0);
        if (status != CONTINUE) return 0;
        state = ctrl.nextState(state, parsed_inst);
        break;
    }

계산된 주소(ALUOut)에서 데이터 읽기
읽은 데이터를 MDR(Memory Data Register)에 저장

Load write

    case S4_LW_WB: {
        rf.write(parsed_inst.rt, MDR, controls.RegWrite);
        state = S0_IFETCH;
        break;
    }

MDR의 데이터를 rt 레지스터에 쓰기

Store memory access

    case S3_SW_MEM: {
        mem.memAccess(ALUOut, nullptr, B, 0, controls.MemWrite);
        if (status != CONTINUE) return 0;
        state = S0_IFETCH;
        break;
    }

계산된 주소(ALUOut)에 데이터(B) 쓰기

branch 비교

    case S2_BRANCH_COMP: {
        uint32_t result;
        alu.compute(A, B, 0, controls.ALUOp, &result);
        ALUOut = result;
        state = ctrl.nextState(state, parsed_inst);
        break;
    }

두 레지스터 값(A, B) 비교
비교 결과를 ALUOut에 저장

branch 결정

    case S3_BRANCH_DECIDE: {
        if (ALUOut == 1) {
            uint32_t imm_ext;
            ctrl.signExtend(parsed_inst.immi, 1, &imm_ext);
            PC = PC + (static_cast<int32_t>(imm_ext) << 2);
        }
        state = S0_IFETCH;
        break;
    }

비교 결과가 참이면 분기 수행
immediate 값을 부호 확장하고 4를 곱해 오프셋 계산
PC에 오프셋 더하기

Jump

    case S2_JUMP: {
        PC = (PC & 0xf0000000) | (parsed_inst.immj << 2);
        state = S0_IFETCH;
        break;
    }

    case S2_JAL_SAVE: {
        rf.write(31, PC, controls.RegWrite); // Save return address
        state = ctrl.nextState(state, parsed_inst);
        break;
    }

    case S3_JAL_JUMP: {
        PC = (PC & 0xf0000000) | (parsed_inst.immj << 2);
        state = S0_IFETCH;
        break;
    }

    case S2_JR: {
        PC = A;
        state = S0_IFETCH;
        break;
    }

S2_JUMP: 직접 jump 수행
PC의 상위 4비트 유지, 하위 28비트를 target 주소로 설정
S2_JAL_SAVE: 리턴 주소를 $ra에 저장
S3_JAL_JUMP: JAL의 jump 수행
S2_JR: 레지스터에 저장된 주소로 jump

• CTRL.cpp

Instruction 분석

void CTRL::splitInst(uint32_t inst, ParsedInst* parsed_inst) {
	parsed_inst->opcode = (inst >> 26) & 0x3F;
	parsed_inst->rs = (inst >> 21) & 0x1F;
	parsed_inst->rt = (inst >> 16) & 0x1F;
	parsed_inst->rd = (inst >> 11) & 0x1F;
	parsed_inst->shamt = (inst >> 6) & 0x1F;
	parsed_inst->funct = inst & 0x3F;
	parsed_inst->immi = inst & 0xFFFF;
	parsed_inst->immj = inst & 0x3FFFFFF;
}

32비트 MIPS 명령어를 각 필드로 분리
opcode (31-26비트): 명령어 종류 식별 (6비트)
rs (25-21비트): 첫 번째 소스 레지스터 (5비트)
rt (20-16비트): 두 번째 소스 레지스터 또는 목적지 (5비트)
rd (15-11비트): 목적지 레지스터 (R-type용, 5비트)
shamt (10-6비트): 시프트 양 (5비트)
funct (5-0비트): 함수 코드 (R-type용, 6비트)
immi: I-type 명령어용 immediate 값 (16비트)
immj: J-type 명령어용 jump target (26비트)

다음 상태 결정

State CTRL::nextState(State current, const ParsedInst& inst) {
	switch (current) {
	case S0_IFETCH:
		return S1_IDECODE;

	case S1_IDECODE:
		switch (inst.opcode) {
		case OP_RTYPE:
			if (inst.funct == FUNCT_JR) return S2_JR;
			else return S2_RTYPE_EXEC;
		case OP_LW: return S2_LW_ADDR;
		case OP_SW: return S2_SW_ADDR;
		case OP_BEQ:
		case OP_BNE: return S2_BRANCH_COMP;
		case OP_J: return S2_JUMP;
		case OP_JAL: return S2_JAL_SAVE;
		case OP_ADDIU:
		case OP_ANDI:
		case OP_ORI:
		case OP_XORI:
		case OP_SLTI:
		case OP_SLTIU:
		case OP_LUI: return S2_ITYPE_EXEC;
		default:
			cerr << "[CTRL] INVALID OPCODE: " << hex << inst.opcode << endl;
			status = INVALID_INST;
			return S0_IFETCH;
		}

현재 상태와 명령어를 기반으로 다음 상태 결정
IFETCH 상태 다음은 항상 IDECODE
IDECODE 상태에서는 opcode에 따라 다음 상태 결정:
- R-type: JR이면 S2_JR, 아니면 S2_RTYPE_EXEC
- Load/Store: 주소 계산 상태로
- 분기: 비교 상태로
- 점프: 각각의 점프 처리 상태로
- I-type: 즉시 실행 상태로

	case S2_RTYPE_EXEC: return S3_RTYPE_WB;
	case S2_ITYPE_EXEC: return S3_ITYPE_WB;
	case S2_LW_ADDR: return S3_LW_MEM;
	case S3_LW_MEM: return S4_LW_WB;
	case S2_SW_ADDR: return S3_SW_MEM;
	case S2_BRANCH_COMP: return S3_BRANCH_DECIDE;
	case S2_JAL_SAVE: return S3_JAL_JUMP;

	default:
		return S0_IFETCH;
	}
}

각 실행 단계 후의 다음 상태 정의
대부분의 명령어는 실행 후 쓰기 단계로
메모리 접근은 추가 단계 필요
기본적으로 IFETCH로 돌아감

control signal 설정

void CTRL::setControlSignals(State state, const ParsedInst& inst, Controls* c) {
	c->ALUOp = 0;
	c->ALUSrc = 0;
	c->ALUSrcA = 0;
	c->ALUSrcB = 0;
	c->Branch = 0;
	c->IorD = 0;
	c->IRWrite = 0;
	c->JR = 0;
	c->Jump = 0;
	c->MemRead = 0;
	c->MemtoReg = 0;
	c->MemWrite = 0;
	c->PCSource = 0;
	c->PCWrite = 0;
	c->PCWriteCond = 0;
	c->RegDst = 0;
	c->RegWrite = 0;
	c->SavePC = 0;
	c->SignExtend = 0;

ALUOp: ALU 연산 종류
ALUSrc: ALU 입력 선택
ALUSrcA/B: ALU 입력 소스 선택
Branch: 분기 명령어 표시
IorD: 메모리 주소 선택
IRWrite: 명령어 레지스터 쓰기
JR/Jump: 점프 관련 제어
MemRead/Write: 메모리 접근 제어
MemtoReg: 레지스터 쓰기 데이터 선택
PCSource/Write: PC 제어
RegDst/Write: 레지스터 파일 제어
SignExtend: 부호 확장 제어

각 상태별 control signal 설정

	switch (state) {
	case S0_IFETCH:
		c->MemRead = 1;
		c->IRWrite = 1;
		c->PCWrite = 1;
		c->IorD = 0;
		c->ALUSrcA = 0;
		c->ALUSrcB = 1;
		c->ALUOp = ALU_ADDU;
		c->PCSource = 0;
		break;

	case S1_IDECODE:
		c->ALUSrcA = 0;
		c->ALUSrcB = 3;
		c->ALUOp = ALU_ADDU;
		break;

IFETCH 상태:
- 메모리 읽기, IR 쓰기, PC 갱신 활성화
- ALU로 다음 PC 계산
IDECODE 상태:
- ALU 입력 설정 (branch 주소 계산용)

R-type instruction 실행 제어

	case S2_RTYPE_EXEC:
		c->ALUSrcA = 1;
		c->ALUSrcB = 0;
		switch (inst.funct) {
		case FUNCT_ADDU: c->ALUOp = ALU_ADDU; break;
		case FUNCT_SUBU: c->ALUOp = ALU_SUBU; break;
		case FUNCT_AND:  c->ALUOp = ALU_AND;  break;
		case FUNCT_OR:   c->ALUOp = ALU_OR;   break;
		case FUNCT_XOR:  c->ALUOp = ALU_XOR;  break;
		case FUNCT_NOR:  c->ALUOp = ALU_NOR;  break;
		case FUNCT_SLT:  c->ALUOp = ALU_SLT;  break;
		case FUNCT_SLTU: c->ALUOp = ALU_SLTU; break;
		case FUNCT_SLL:  c->ALUOp = ALU_SLL;  break;
		case FUNCT_SRA:  c->ALUOp = ALU_SRA;  break;
		case FUNCT_SRL:  c->ALUOp = ALU_SRL;  break;
		default:
			status = UNSUPPORTED_ALU;
			break;
		}
		break;

ALU 입력을 레지스터 값으로 설정
funct 필드에 따라 ALU 연산 설정

나머지 상태들 제어

	case S3_RTYPE_WB:
		c->RegDst = 1;
		c->RegWrite = 1;
		c->MemtoReg = 0;
		break;

	case S2_ITYPE_EXEC:
		c->ALUSrcA = 1;
		c->ALUSrcB = 2;  // imm
		c->SignExtend = (inst.opcode != OP_ANDI && inst.opcode != OP_ORI && inst.opcode != OP_XORI);
		switch (inst.opcode) {
		case OP_ADDIU: c->ALUOp = ALU_ADDU; break;
		case OP_ANDI:  c->ALUOp = ALU_AND; break;
		case OP_ORI:   c->ALUOp = ALU_OR; break;
		case OP_XORI:  c->ALUOp = ALU_XOR; break;
		case OP_SLTI:  c->ALUOp = ALU_SLT; break;
		case OP_SLTIU: c->ALUOp = ALU_SLTU; break;
		case OP_LUI:   c->ALUOp = ALU_LUI; break;
		}
		break;

	case S3_ITYPE_WB:
		c->RegDst = 0;
		c->RegWrite = 1;
		c->MemtoReg = 0;
		break;

	case S2_LW_ADDR:
	case S2_SW_ADDR:
		c->ALUSrcA = 1;
		c->ALUSrcB = 2;
		c->ALUOp = ALU_ADDU;
		break;

	case S3_LW_MEM:
		c->MemRead = 1;
		c->IorD = 1;
		break;

	case S4_LW_WB:
		c->RegDst = 0;
		c->RegWrite = 1;
		c->MemtoReg = 1;
		break;

	case S3_SW_MEM:
		c->MemWrite = 1;
		c->IorD = 1;
		break;

	case S2_BRANCH_COMP:
		c->ALUSrcA = 1;
		c->ALUSrcB = 0;
		c->ALUOp = (inst.opcode == OP_BEQ) ? ALU_EQ : ALU_NEQ;
		break;

	case S3_BRANCH_DECIDE:
		c->PCWriteCond = 1;
		c->PCSource = 1;
		break;

	case S2_JUMP:
	case S3_JAL_JUMP:
		c->PCWrite = 1;
		c->PCSource = 2;
		break;

	case S2_JAL_SAVE:
		c->RegWrite = 1;
		c->SavePC = 1;
		break;

	case S2_JR:
		c->PCWrite = 1;
		c->PCSource = 3;
		c->JR = 1;
		break;

R-type 쓰기: rd 레지스터에 ALU 결과 저장
I-type 실행: immediate 값과 레지스터 연산
Load/Store: 메모리 주소 계산과 접근
분기: 조건 비교와 PC 갱신
점프: PC 갱신과 리턴 주소 저장

2. verilog에서 구현

• CPU.v

FSM 구현

always @(posedge clk or negedge reset_n) begin
    if (!reset_n) begin
        state <= S0_IFETCH;
        PC_reg <= 32'h0;
        IR <= 32'h0;
        A <= 32'h0;
        B <= 32'h0;
        ALUOut <= 32'h0;
        MDR <= 32'h0;
    end else begin
        case (state)
            S0_IFETCH: begin
                IR <= mem_data;
                PC_reg <= PC_reg + 4;
                state <= S1_IDECODE;
            end
            
            S1_IDECODE: begin
                A <= reg_file[rs];
                B <= reg_file[rt];
                case (opcode)
                    OP_RTYPE: state <= S2_RTYPE_EXEC;
                    OP_LW, OP_SW: state <= S2_MEM_ADDR;
                    OP_BEQ, OP_BNE: state <= S2_BRANCH;
                    OP_J, OP_JAL: state <= S2_JUMP;
                endcase
            end
            
            S2_RTYPE_EXEC: begin
                case (funct)
                    FUNC_ADD: ALUOut <= A + B;
                    FUNC_SUB: ALUOut <= A - B;
                    FUNC_AND: ALUOut <= A & B;
                    FUNC_OR:  ALUOut <= A | B;
                    FUNC_SLT: ALUOut <= ($signed(A) < $signed(B)) ? 32'h1 : 32'h0;
                endcase
                state <= S3_RTYPE_WB;
            end
            
            S2_MEM_ADDR: begin
                ALUOut <= A + {{16{immediate[15]}}, immediate};
                state <= (opcode == OP_LW) ? S3_LW_MEM : S3_SW_MEM;
            end
            
            S3_LW_MEM: begin
                MDR <= mem_data;
                state <= S4_LW_WB;
            end
            
            S3_SW_MEM: begin
                mem_write_data <= B;
                mem_write_en <= 1'b1;
                state <= S0_IFETCH;
            end

S0_IFETCH: 메모리에서 명령어 가져오기
S1_IDECODE: 명령어 해석 및 레지스터 읽기
S2_RTYPE_EXEC: R-type 명령어 실행
S2_MEM_ADDR: 메모리 주소 계산
S3_LW_MEM/S3_SW_MEM: 메모리 읽기/쓰기
S4_LW_WB: 레지스터에 데이터 쓰기

2 branch 및 jump

S2_BRANCH: begin
    case (opcode)
        OP_BEQ: begin
            if (A == B)
                PC_reg <= PC_reg + {{16{immediate[15]}}, immediate} << 2;
        end
        OP_BNE: begin
            if (A != B)
                PC_reg <= PC_reg + {{16{immediate[15]}}, immediate} << 2;
        end
    endcase
    state <= S0_IFETCH;
end

S2_JUMP: begin
    PC_reg <= {PC_reg[31:28], jump_target, 2'b00};
    if (opcode == OP_JAL)
        reg_file[31] <= PC_reg + 4;
    state <= S0_IFETCH;
end

• CTRL.v

control signal 생성

always @(*) begin
    case (state)
        S0_IFETCH: begin
            MemRead = 1'b1;
            ALUSrcA = 2'b00;    // PC 선택
            ALUSrcB = 2'b01;    // 4 선택
            ALUOp = 3'b000;     // 덧셈
            PCWrite = 1'b1;
            PCSource = 2'b00;   // ALU 결과
        end

        S1_IDECODE: begin
            ALUSrcA = 2'b00;    // PC 선택
            ALUSrcB = 2'b11;    // 분기 오프셋
            ALUOp = 3'b000;     // 덧셈
        end

        S2_RTYPE_EXEC: begin
            ALUSrcA = 2'b01;    // A 레지스터
            ALUSrcB = 2'b00;    // B 레지스터
            case (funct)
                FUNC_ADD: ALUOp = 3'b000;
                FUNC_SUB: ALUOp = 3'b001;
                FUNC_AND: ALUOp = 3'b010;
                FUNC_OR:  ALUOp = 3'b011;
                FUNC_SLT: ALUOp = 3'b100;
            endcase
        end

memory access 제어

S2_MEM_ADDR: begin
    ALUSrcA = 2'b01;    // A 레지스터
    ALUSrcB = 2'b10;    // 확장된 immediate
    ALUOp = 3'b000;     // 덧셈
end

S3_LW_MEM: begin
    MemRead = 1'b1;
    IorD = 1'b1;        // ALUOut으로부터 주소
end

S3_SW_MEM: begin
    MemWrite = 1'b1;
    IorD = 1'b1;        // ALUOut으로부터 주소
end

2.3 레지스터 쓰기 제어

S3_RTYPE_WB: begin
    RegWrite = 1'b1;
    RegDst = 1'b1;      // rd 필드 선택
    MemtoReg = 1'b0;    // ALUOut 선택
end

S4_LW_WB: begin
    RegWrite = 1'b1;
    RegDst = 1'b0;      // rt 필드 선택
    MemtoReg = 1'b1;    // MDR 선택
end

ALUSrcA/B: ALU 입력 선택
ALUOp: ALU 연산 종류
RegDst: 목적지 레지스터 선택
MemtoReg: 레지스터 쓰기 데이터 선택
RegWrite: 레지스터 쓰기 활성화
MemRead/Write: 메모리 접근 제어
PCWrite: PC 갱신 제어

3. Result

1. cpp 실행 결과

kontrack@DESKTOP-BJ4BPMI:~/HW4$ make clean
rm -f main.o CPU.o ALU.o RF.o MEM.o CTRL.o cpu *.mem
kontrack@DESKTOP-BJ4BPMI:~/HW4$ make
g++ -Wall -Wextra -O2 -c main.cpp -o main.o
g++ -Wall -Wextra -O2 -c CPU.cpp -o CPU.o
g++ -Wall -Wextra -O2 -c ALU.cpp -o ALU.o
g++ -Wall -Wextra -O2 -c RF.cpp -o RF.o
g++ -Wall -Wextra -O2 -c MEM.cpp -o MEM.o
g++ -Wall -Wextra -O2 -c CTRL.cpp -o CTRL.o
g++ -Wall -Wextra -O2 -o cpu main.o CPU.o ALU.o RF.o MEM.o CTRL.o
kontrack@DESKTOP-BJ4BPMI:~/HW4$ ./cpu testcase7.hex
Loading instruction memory...
Starting CPU simulation...
c
Simulation done successfully.
RF states after the program execution
$zero 00000000
$at   e2810000
$v0   00000000
$v1   00000000
$a0   00000000
$a1   00000000
$a2   00000000
$a3   00000000
$t0   ffffffff
$t1   00000000
$t2   ffffffff
$t3   ffffffff
$t4   00000000
$t5   00000000
$t6   00000000
$t7   00000000
$s0   00000000
$s1   00000000
$s2   00000000
$s3   00000000
$s4   00000000
$s5   00000000
$s6   00000000
$s7   00000000
$t8   00000000
$t9   00000000
$k0   00000000
$k1   00000000
$gp   00001800
$sp   00003ffc
$fp   00000000
$ra   00000000

make을 통해 컴파일 하여 생성된 cpu에 testcase1.hex를 명령인자로 넣고 실행 한 결과 정상적으로 Starting CPU simulation...의 message가 출력되었다.
여기에 s를 통해 1cycle을 움직이고 r로 register의 결과를 dump하면서 MARS와 1 step씩 비교하며 정상적으로 구동되는지를 확인하였다. ^{1 step 실행 결과} ^{run all 결과}
모든 결과가 일치하는 것을 확인하였다.

program이 종료된 후 verilog testbench를 위한 .mem파일이 정상적으로 생성되었다.

이후 모든 testcase에 대해서도 시뮬레이션이 성공을 반환하는 것을 확인하였다.

2. verilog 실행 결과

⋯
launch_simulation: Time (s): cpu = 00:00:16 ; elapsed = 00:00:18 . Memory (MB): peak = 3132.801 ; gain = 0.000
run all
Program Terminate

Simulation success!!!
$finish called at time : 8515 ns : File "C:/Users/LG/HW4/HW4.srcs/sources_1/imports/verilog/CPU_tb.v" Line 57

앞서 testcase1.hex에 대해 cpp이 생성했던 .mem file들 바탕으로 vivado에서 verilog 코드를 수행해본 결과 성공적으로 simulation을 완료하였다.

이후 모든 testcase에 대해서도 시뮬레이션이 성공을 반환하는 것을 확인하였다. ^{run all 결과}

4. Troubleshooting

1. Branch 명령어 처리 오류

문제
Branch 명령어(BEQ, BNE) 실행 시 잘못된 분기가 발생하여 프로그램이 예상치 못한 경로로 실행되는 현상이 발생했다. 특히 테스트케이스 2에서 branch 조건 확인과 target 주소 계산이 부정확하게 처리되었다.

원인

Branch 조건 확인 시 ALU 결과값의 최하위 비트(alu_result[0])만을 확인하여, 전체 비교 결과를 정확하게 반영하지 못했다.
Branch target 주소 계산이 PC_next 로직에 의존적이었으며, S3_BRANCH_DECIDE 상태에서 직접적으로 계산되지 않았다.

해결

Branch 조건 확인을 ALUOut == 32'b1로 변경하여 ALU의 전체 비교 결과를 정확하게 반영
S3_BRANCH_DECIDE 상태에서 branch target 주소를 PC + (sign_extended_immediate << 2)로 직접 계산하도록 수정
PC 업데이트 로직을 수정하여 branch 상태일 때 별도의 주소 계산을 수행하도록 변경

결과

Branch 명령어의 조건 판단이 정확하게 이루어져 올바른 분기 결정이 가능해짐
Branch target 주소가 정확하게 계산되어 의도한 주소로 정확한 분기가 이루어짐
테스트케이스 2의 모든 branch 명령어가 정상적으로 동작하게 됨

HW4 - Kontrack/for_wiki GitHub Wiki

Outline

1. Design

1. additional control signals

2. FSM

2. Implement

1. cpp에서 구현

• CPU.cpp

• CTRL.cpp

2. verilog에서 구현

• CPU.v

• CTRL.v

2.3 레지스터 쓰기 제어

3. Result

1. cpp 실행 결과

2. verilog 실행 결과

4. Troubleshooting

1. Branch 명령어 처리 오류

⚠️ GitHub.com Fallback ⚠️

HW4 - Kontrack/for_wiki GitHub Wiki

Outline

1. Design

1. additional control signals

2. FSM

2. Implement

1. cpp에서 구현

• CPU.cpp

• CTRL.cpp

2. verilog에서 구현

• CPU.v

• CTRL.v

2.3 레지스터 쓰기 제어

3. Result

1. cpp 실행 결과

2. verilog 실행 결과

4. Troubleshooting

1. Branch 명령어 처리 오류

⚠️ **GitHub.com Fallback** ⚠️

⚠️ GitHub.com Fallback ⚠️