파이프라이닝

// 파이프라인 단계 간 데이터를 보관하는 파이프라인 레지스터
typedef struct { unsigned int pc, instruction; }           IF_ID;
typedef struct { unsigned int pc, opcode, rs, rt, rd, imm; } ID_EX;
typedef struct { unsigned int alu_result, rt_val, rd, opcode; } EX_MEM; // opcode: MEM 단계 판별용 제어 신호
typedef struct { unsigned int result, rd; }                    MEM_WB;

// 파이프라인 레지스터 전역 선언
IF_ID  if_id   = {0};
ID_EX  id_ex   = {0};
EX_MEM ex_mem  = {0};
MEM_WB mem_wb  = {0};

// 각 단계 함수 — 한 클럭에 동시 실행됨
void stage_IF(unsigned int *pc, unsigned int *mem) {
    if_id.instruction = mem[*pc];  // 명령어 인출
    if_id.pc = (*pc)++;            // PC 증가
}

void stage_ID() {
    id_ex.opcode = (if_id.instruction >> 26) & 0x3F;
    id_ex.rs     = (if_id.instruction >> 21) & 0x1F;
    id_ex.rt     = (if_id.instruction >> 16) & 0x1F;
    id_ex.rd     = (if_id.instruction >> 11) & 0x1F;
    id_ex.imm    =  if_id.instruction        & 0xFFFF;
    id_ex.pc     =  if_id.pc;
}

void stage_EX(unsigned int *regs) {
    ex_mem.rd     = id_ex.rd;
    ex_mem.rt_val = regs[id_ex.rt];
    ex_mem.opcode = id_ex.opcode;  // 제어 신호를 EX/MEM 레지스터로 전파 (MEM 단계가 사용)
    switch (id_ex.opcode) {
        case 0x00: ex_mem.alu_result = regs[id_ex.rs] + regs[id_ex.rt]; break; // ADD
        case 0x23: ex_mem.alu_result = regs[id_ex.rs] + id_ex.imm;    break; // LOAD
        case 0x2B: ex_mem.alu_result = regs[id_ex.rs] + id_ex.imm;    break; // STORE
    }
}

void stage_MEM(unsigned int *data_mem) {
    mem_wb.rd = ex_mem.rd;
    if (ex_mem.opcode == 0x23)       // LOAD  — EX/MEM 레지스터의 opcode 사용 (id_ex는 EX 단계 명령어)
        mem_wb.result = data_mem[ex_mem.alu_result];
    else if (ex_mem.opcode == 0x2B)  // STORE — 동일
        data_mem[ex_mem.alu_result] = ex_mem.rt_val;
    else
        mem_wb.result = ex_mem.alu_result;
}

void stage_WB(unsigned int *regs) {
    regs[mem_wb.rd] = mem_wb.result;  // 결과를 레지스터에 기록
}

// 한 클럭 사이클 실행 — 5단계가 동시에 작동
void clock_cycle(unsigned int *pc,
                  unsigned int *instr_mem,
                  unsigned int *data_mem,
                  unsigned int *regs) {
    stage_WB(regs);        // WB 먼저 — 포워딩 충돌 방지
    stage_MEM(data_mem);
    stage_EX(regs);
    stage_ID();
    stage_IF(pc, instr_mem);
}

// 데이터 해저드 감지 및 스톨 삽입 시뮬레이터
public class PipelineSimulator {

    private int[] registers = new int[32];
    private int   stallCount = 0;

    // 파이프라인 레지스터 (단계 간 데이터 보관)
    private int ifId_instr, idEx_rd, exMem_rd, memWb_rd;
    private boolean idEx_regWrite, exMem_regWrite;

    /**
     * 데이터 해저드(RAW) 감지
     * — ID 단계 명령어의 소스 레지스터가
     *   앞선 명령어의 목적지 레지스터와 겹치는지 확인
     */
    private boolean detectDataHazard(int rs, int rt) {
        // EX/MEM 해저드: 2클럭 앞 명령어가 MEM 단계에 있고 아직 WB 미완료
        // (Patterson & Hennessy 조건 1: EX/MEM.RegisterRd == 현재 명령어 소스)
        if (exMem_regWrite && exMem_rd != 0 &&
            (exMem_rd == rs || exMem_rd == rt)) {
            return true;
        }
        // ID/EX 해저드: 1클럭 앞 명령어가 EX 단계에 있고 아직 WB 미완료
        // (Patterson & Hennessy 조건 2: ID/EX.RegisterRd == 현재 명령어 소스)
        // idEx_rd = ID/EX 파이프라인 레지스터 → EX 단계의 명령어 (MEM/WB가 아님)
        if (idEx_regWrite && idEx_rd != 0 &&
            (idEx_rd == rs || idEx_rd == rt)) {
            return true;
        }
        return false;
    }

    /**
     * 스톨(Bubble) 삽입
     * — 해저드 감지 시 NOP을 끼워 파이프라인을 1클럭 지연
     */
    private void insertStall() {
        // ID/EX 레지스터를 NOP(버블)으로 초기화
        idEx_rd       = 0;
        idEx_regWrite = false;
        stallCount++;
        System.out.printf("[STALL] 버블 삽입 — 총 스톨 횟수: %d%n", stallCount);
    }

    /**
     * 포워딩(Forwarding) — 스톨 없이 해저드 해소
     * 표준 포워딩 경로:
     *   EX/MEM → EX: exMem 레지스터 (2클럭 앞 명령어, MEM 단계)
     *   ID/EX  → EX: idEx  레지스터 (1클럭 앞 명령어, EX 단계)
     * ※ 이 시뮬레이터는 단순화를 위해 registers[]에서 값을 읽습니다.
     *   실제 하드웨어에서는 파이프라인 레지스터의 결과 필드를 직접 바이패스합니다.
     */
    private int forwardValue(int regNum) {
        if (exMem_regWrite && exMem_rd == regNum) {
            System.out.println("[FORWARD] EX/MEM → EX (MEM 단계 명령어에서 EX 단계로)");
            return registers[exMem_rd]; // EX/MEM 포워딩
        }
        if (idEx_regWrite && idEx_rd == regNum) {
            System.out.println("[FORWARD] ID/EX → EX (EX 단계 명령어에서 EX 단계로)");
            return registers[idEx_rd];  // ID/EX 포워딩 (idEx = EX 단계의 명령어, MEM/WB 아님)
        }
        return registers[regNum];
    }
}