手把手代码实现五级流水线CPU——第一篇：初级顺序流水线

已于 2023-01-02 12:00:14 修改
阅读量1.9k 收藏 22
点赞数 2
分类专栏： CSAPP——实现cpu RISC-V 文章标签： 嵌入式硬件 risc-v c语言
于 2023-01-02 11:17:05 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Strive_LiJiaLe/article/details/128518972
版权

文章目录

指令系统

在这里插入图片描述

编码格式

在这里插入图片描述

一、基础：顺序结构

1.取值阶段：

  • 根据icode还可以判断当前指令是否包含寄存器指示符字节（Need regids）；以及是否包含常数字节（Need valC），由此计算出指令的长度，进而计算下一条地址

  • 当need_regids等于0时，表示这条指令没有寄存器指示符，rA和rB置为0xF；当指令中只含有一个寄存器操作数时，同样另一个字段置为0xF

  • 当need_regids等于0时，第1个字节到第8个表示常数字段valC，1时，2~9

2.译码阶段

  • 产生寄存器ID值，需要指令代码icode和rA、rB读取寄存器的数据，rA用于pop（call、ret）指令指针值

3.执行阶段

  • ALU根据指令功能（ifun）来判断对输入的操作数进行何种运算，都会产生条件码信号，但对于计算内存引用地址以及栈操作时，不必设置条件码，通过设置setCC，可根据icode来控制是否要更新条件码寄存器CC；标号为cond的硬件单元会根据指令功能和条件码寄存器产生一个cnd信号
  • 对于跳转指令，如果cnd=1，执行跳转，否则不跳转

4.访存阶段

  • 就是从内存中读数据或者将数据写入内存中，根据信号计算状态码Stat
    读控制块，写控制块，产生内存地址和输入数据的控制块

5.写回阶段

  • 将数据写入寄存器文件
    两个写端口分别为M和E，对应的地址输入为dstE和dstM。当执行条件传送指令（cmov）时，写入操作还需根据执行阶段计算出的cnd信号；当不满足条件时，可以将目的寄存器设置为0xF来禁止写入寄存器文件

6.更新PC阶段

  • call指令
    常数字段
  • ret指令
    内存（栈）中读出返回地址
  • jxx跳转指令
    满足cnd，常数字段；否则，与其他一样，加上当前指令长度

详细硬件结构

在这里插入图片描述

指令在各个阶段完成的操作

在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
更多指令操作请查找：Y86指令集

C代码实现

#include<stdio.h>
#include<stdint.h>
#include<string.h>
/*
寄存器编号
*/
enum Reg {
	rax = 0,
	rcx = 1,
	rdx = 2,
	rbx = 3,
	rsp = 4,
	rbp = 5,
	rsi = 6,
	rdi = 7,
	r8 = 8,
	r9 = 9,
	r10 = 0xA,
	r11 = 0xB,
	r12 = 0xC,
	r13 = 0xD,
	r14 = 0xE,
	No_regisEer = 0xF,
};
const uint8_t PC_memory[32768] = { 0x30,0xf2,0x09,0x00,0x00,0x00,0x00,0x00,0x00,0x00		//0x000 : irmovq  $9,   %rdx
								  ,0x30,0xf3,0x15,0x00,0x00,0x00,0x00,0x00,0x00,0x00		//0x00a	: irmovq  $21,  %rbx
								  ,0x61,0x23												//0x014	: subq   %rdx,  %rbx
								  ,0x30,0xf4,0x80,0x00,0x00,0x00,0x00,0x00,0x00,0x00		//0x016	: irmovq  $128, %rsp
								  ,0x40,0x43,0x64,0x00,0x00,0x00,0x00,0x00,0x00,0x00		//0x020	: rmmovq %rsp,  100(%rbx)
								  ,0xa0,0x2f												//0x02a	: pushq  %rdx 
								  ,0xb0,0x0f												//0x02c	: popq   %rax  
								  ,0x73,0x40,0x00,0x00,0x00,0x00,0x00,0x00,0x00				//0x02e	: je done
								  ,0x80,0x41,0x03,0x00,0x00,0x00,0x00,0x00,0x00				//0x037	: call proc
	//0x040	: done:
,0x00														//0x040	:     halt
//0x041	: proc:
,0x90 };													//0x041	:     ret
struct FReg {
	int predPC;
};
struct SelectPC {			//PC选择逻辑单元，预测与纠错
	int predpc;				//经过predicatePC单元，判断jxx，call跳转 还是 其他顺序执行PCinc单元（valp），预测
	int cnd;				//执行jxx valc的限制条件，默认跳转，cnd=0  顺序执行valp					，修正jxx
	int M_valA;				//通过selectA将valp放入valA里了										
	int M_icode;
	int W_valM;				//ret默认顺序执行valp，待从栈Datamemory中读地址后更新					，修正ret
	int W_icode;
};
struct F_DReg {
	int stat;
	int icode;
	int ifuc;
	int rA;
	int rB;
	int valC;
	int valP;
};
struct D_EReg {
	int stat;
	int icode;
	int ifuc;
	int valC;
	int valA;
	int valB;
	int dstE;
	int dstM;
	int srcA;
	int srcB;
};

struct FwdB {
	int register_B;
	int srcB;
	int E_dstE;
	int E_valE;
	int M_dstE;
	int M_valE;
	int M_dstM;
	int M_valM;
	int W_dstM;
	int W_valM;
	int W_dstE;
	int W_valE;
	int valB;
};
struct SelectA_and_FwdA {
	int register_A;
	int srcA;
	int valP;
	int E_dstE;
	int E_valE;
	int M_dstE;
	int M_valE;
	int M_dstM;
	int M_valM;
	int W_dstM;
	int W_valM;
	int W_dstE;
	int W_valE;
	int valA;
};
struct E_MReg {
	int stat;
	char icode;
	int Cnd;
	int valE;
	int valA;
	int dstE;
	int dstM;
};
struct CC {
	int ZF;
	int SF;
	int OF;
};
struct M_WReg {
	int stat;
	int icode;
	int valE;
	int valM;
	int dstE;
	int dstM;
};
struct Inst {
	int icode;
	int ifunct;
	int rA_id;
	int rB_id;
	int valC;
	int valP;
	int len;
};

int Register_file[16] = { 0 };
int Datamemory[32768] = { 0 };
struct CC cc = { 0 };
struct FReg fReg = { 0 };
struct SelectPC selectpc = { 0,1,0,0,0,0 };
struct FwdB fwdb = { 0 };
struct SelectA_and_FwdA sel_fwda = { 0 };

/*
1.用暂停来避免冒险
只要一条指令的源操作数会被流水线后面某个阶段中的指令产生,处理器就会通过将指令阻塞在解码阶段来避免数据冒险
2.用转发来避免冒险-----》不需要暂停，但与存储器读有关的指令，是在流水线较后面发生的，仍需暂停
如mr 0(%edx),%eax 指令后紧接着add %ebx,&eax ;add的%eax需要在译码阶段得到值，而mr最早到访存阶段才能转发
显然已经来不及，所以不得不先暂停后转发
3.暂停+转发
将解码阶段中的指令暂停一个周期,导致执行阶段中插入一个气泡，同时暂停，使得F和D状态不变

需要解决的控制逻辑：插入气泡
1.加载使用冒险：1个气泡
	在一条从存储器中读出一个值的指令和一条使用该值的指令之间,流水线必须暂停一个周期
2. ret:3个气泡
	流水线必须暂停直到ret指令到达写回阶段
3. 预测错误的分支:两个气泡
	在分支逻辑发现不应该选择分支之前（执行阶段才发现）,分支目标处的几条指令已经进入流水线了。
	必须从流水线中去掉这些指令。
	此时第一条指令已经执行到译码阶段，第二条指令刚开始取指。


具体实现：
定义F_DReg 和F_DRegNew  D_EReg 和D_ERegNew   E_MReg 和E_MRegNew   M_WReg 和M_WRegNew
执行过程中：
	F：输入pc      输出 F_DRegNew；正常情况下需要更新  将F_DRegNew---->F_DReg，否则不变
	D：输入F_DReg  输出 D_ERegNew;
	E: 输入D_EReg  输出 E_MRegNew；
	M: 输入E_MReg  输出 M_WRegNew
	W: 输入M_WReg
每次执行完需要判断：
	需要暂停，就使用原状态F_DReg
	正常情况，每次执行完一个周期需要更新
		F_DReg = F_DRegNew

*

//分支预测
void Select_PC(struct SelectPC* selectpc) {
	if (selectpc->W_icode == 9) {	//ret生效
		selectpc->predpc = selectpc->W_valM;
	}
	if (selectpc->W_icode == 7) {
		if (selectpc->cnd == 0) {	//跳转失败
			selectpc->predpc = selectpc->M_valA;
		}
	}
}
//取值阶段
int Predict_PC(int icode,int valc,int valp) {
	if (icode == 7||icode == 8) {
		return valc;
	}
	else {
		return valp;
	}
}
int PC_inc(int len,int pc) {
	return len + pc;
}
int iValC(int valC_start,int valC_end) {
	int i, j,valc = 0;
	for ( j = 0,i = valC_start; i <= valC_end; i++,j = j + 2)
	{
		valc += PC_memory[i] << j;
	}
	return valc;
}
void Align(int pc,struct Inst* inst,int Need_regids,int Need_valC) {
	int valC_start;
	int valC_end;

	if (Need_regids == 0) {
		inst->rA_id = 0xF;
		inst->rB_id = 0xF;
		if (Need_valC) {	//无寄存器、有常数  如jxx、call
			valC_start = pc + 1;
			valC_end = pc + 8;
			inst->len = 1 + (valC_end - pc);
			inst->valC = iValC(valC_start, valC_end);
		}
		else {				//无寄存器、无常数  如halt、nop、ret
			inst->len = 1;
		}
	}
	if (Need_regids == 1) {
		inst->rA_id = 0xF;
		inst->rB_id = PC_memory[pc + 1] & 0x0F;
		if (Need_valC) {	//只有寄存器rB、有常数  如irmovq
			valC_start = pc + 2;
			valC_end = pc + 9;
			inst->len = 1 + (valC_end - pc);
			inst->valC = iValC(valC_start, valC_end);
		}
		//只有寄存器rB、无常数  此情况无
	}
	if (Need_regids == 2) {
		inst->rA_id = PC_memory[pc + 1] >> 4;
		inst->rB_id = 0xF;
		//只有寄存器rA、有常数  此情况无
		if (!Need_valC) {	//有寄存器rA、无常数  如pushq、popq
			inst->len = 2;
		}
	}
	if (Need_regids == 3) {
		inst->rA_id = PC_memory[pc + 1] >> 4;
		inst->rB_id = PC_memory[pc + 1] & 0x0F;
		if (Need_valC) {	//都有寄存器、有常数  如rrmovq、rmmovq、mrmovq
			valC_start = pc + 2;
			valC_end = pc + 9;
			inst->len = 1 + (valC_end - pc);
			inst->valC = iValC(valC_start, valC_end);
		}
		else {
			// 都有寄存器、无常数  如addq、subq、andq、xorq、rrmovq、rrmovq、cmovle、cmovl、cmove、cmovne、cmovge、cmovg
			inst->len = 2;
		}
	}

}
void Split(int pc, struct Inst* inst, struct F_DReg* f_dReg) {
	int Need_valC;
	int Need_regids;					//0：都为空；1：rA为空；2：rB为空；3：都不为空
	uint8_t code = PC_memory[pc];
	uint8_t reg = PC_memory[pc + 1];
	inst->icode = (uint8_t)(code >> 4);
	inst->ifunct = code & 0x0F;
	if (inst->icode == 0 && inst->ifunct == 0) {
		Need_regids = 0;
		Need_valC = 0;
		Align(pc,inst, Need_regids, Need_valC);
	}
	if (inst->icode == 1 && inst->ifunct == 0) {
		Need_valC = 0;
		Need_regids = 0;
		Align(pc, inst, Need_regids, Need_valC);
	}
	if (inst->icode == 2) {
		Need_valC = 0;
		Need_regids = 3;
		Align(pc, inst, Need_regids, Need_valC);
	}
	if (inst->icode == 3 && inst->ifunct == 0) {
		Need_valC = 1;
		Need_regids = 1;
		Align(pc, inst, Need_regids, Need_valC);
	}
	if (inst->icode == 4 && inst->ifunct == 0) {
		Need_valC = 1;
		Need_regids = 3;
		Align(pc, inst, Need_regids, Need_valC);
	}
	if (inst->icode == 5 && inst->ifunct == 0) {
		Need_valC = 1;
		Need_regids = 3;
		Align(pc, inst, Need_regids, Need_valC);
	}
	if (inst->icode == 6) {
		Need_valC = 0;
		Need_regids = 3;
		Align(pc, inst, Need_regids, Need_valC);
	}
	if (inst->icode == 7) {
		Need_valC = 1;
		Need_regids = 0;
		Align(pc, inst, Need_regids, Need_valC);
	}
	if (inst->icode == 8 && inst->ifunct == 0) {
		Need_valC = 1;
		Need_regids = 0;
		Align(pc, inst, Need_regids, Need_valC);
	}
	if (inst->icode == 9 && inst->ifunct == 0) {
		Need_valC = 0;
		Need_regids = 0;
		Align(pc, inst, Need_regids, Need_valC);
	}
	if (inst->icode == 0xA && inst->ifunct == 0) {
		Need_valC = 0;
		Need_regids = 2;
		Align(pc, inst, Need_regids, Need_valC);
	}
	if (inst->icode == 0xB && inst->ifunct == 0) {
		Need_valC = 0;
		Need_regids = 2;
		Align(pc, inst, Need_regids, Need_valC);
	}
	if (!(inst->icode >= 0 && inst->icode <= 11)) {
		f_dReg->stat = 0;
	}
}
void Fetch(struct F_DReg* f_dReg,int pc){
	struct Inst inst = {0,0,0,0,0,0,0};
	Split(pc,&inst, f_dReg);
	inst.valP = PC_inc(inst.len, pc);
	fReg.predPC = Predict_PC(inst.icode, inst.valC, inst.valP);
	selectpc.predpc = selectpc.predpc;
	f_dReg->icode = inst.icode;
	f_dReg->ifuc = inst.ifunct;
	f_dReg->rA = inst.rA_id;
	f_dReg->rB = inst.rB_id;
	f_dReg->valC = inst.valC;
	f_dReg->valP = inst.valP;
}

//译码阶段
/*
1.不是所以指令都需要数据转发,而且数据转发阶段也不同：（不需要回写寄存器的指令，不需要转发）
		执行阶段：（ALU计算结果）						  valE：	 3irmov 6opq 2rrmov(有条件) Apush Bpop 8call 9ret（注意：回写valE到SP寄存器）
		访存前：	 （对寄存器写入端口E还没有进行写入的数据）valE： 就是执行阶段的指令
		访存后有：（内存的输出数据）					  valM： 5mrmov（有点晚） Bpop （从Datememory中读出数据后才回写）
		写回阶段：（对寄存器写入端口E还没进行写入的数据）  valE：就是执行阶段的指令
				 （对寄存器写入端口M还没有进行写入的数据）valM： 就是访存后指令
2.rB寄存器作为源寄存器时，需要与rB作为目的寄存器匹配验证的指令很少。有指令：
		opq： rA,rB->rB
		mrmov：D(rB),rA
3.rA寄存器作为源寄存器时，需要与rA作为目的寄存器匹配验证。rA源寄存器有指令：
		特别注意：jxx和call指令要经过selectA，选出的是valP，不是来自寄存器的ra值，所以不需要匹配验证
		mr指令也不需要
*/
//数据转发
void SelectA_and_FwdA(struct SelectA_and_FwdA* sel_fwda) {

	if (sel_fwda->srcA == 0xF) {
		sel_fwda->valA = sel_fwda->valP;
	}
	else {
		if (sel_fwda->srcA == sel_fwda->E_dstE) {
			sel_fwda->valA = sel_fwda->E_valE;
		}
		else if (sel_fwda->srcA == sel_fwda->M_dstE) {
			sel_fwda->valA = sel_fwda->M_valE;
		}
		else if (sel_fwda->srcA == sel_fwda->M_dstM) {
			sel_fwda->valA = sel_fwda->M_valE;
		}
		else if (sel_fwda->srcA == sel_fwda->W_dstE) {
			sel_fwda->valA = sel_fwda->W_valE;
		}
		else if (sel_fwda->srcA == sel_fwda->W_dstM) {
			sel_fwda->valA = sel_fwda->W_valM;
		}
		else {
			sel_fwda->valA = sel_fwda->register_A;
		}
	}

}
void FwdB(struct FwdB* fwdb) {
	if (fwdb->srcB == fwdb->E_dstE) {
		fwdb->valB = fwdb->E_valE;
	}
	else if (fwdb->srcB == fwdb->M_dstE) {
		fwdb->valB = fwdb->M_valE;
	}
	else if (fwdb->srcB == fwdb->M_dstM) {
		fwdb->valB = fwdb->M_valE;
	}
	else if (fwdb->srcB == fwdb->W_dstE) {
		fwdb->valB = fwdb->W_valE;
	}
	else if (fwdb->srcB == fwdb->W_dstM) {
		fwdb->valB = fwdb->W_valM;
	}
	else {
		fwdb->valB = fwdb->register_B;
	}
}
void Decode(struct F_DReg f_dReg, struct D_EReg* d_eReg, int* Register_file) {
	d_eReg->stat = f_dReg.stat;
	d_eReg->icode = f_dReg.icode;
	d_eReg->valC = f_dReg.valC;
	d_eReg->ifuc = f_dReg.ifuc;
	if (f_dReg.icode == 0 || f_dReg.icode == 1) {
		;
	}
	if (f_dReg.icode == 2) {	//rr
		d_eReg->srcA = f_dReg.rA;

		sel_fwda.srcA = f_dReg.rA;
		sel_fwda.register_A = Register_file[f_dReg.rA];
		SelectA_and_FwdA(&sel_fwda);
		d_eReg->valA = sel_fwda.valA;

		d_eReg->srcB = f_dReg.rB;
		d_eReg->valB = 0;

		d_eReg->dstE = f_dReg.rB;		//将结果valE写回寄存器rB
	}
	if (f_dReg.icode == 3) {	//ir
		d_eReg->srcA = f_dReg.rA;
		d_eReg->srcB = f_dReg.rB;
		d_eReg->valB = 0;
		d_eReg->dstE = f_dReg.rB;		//将ALU结果valE写回寄存器rB
	}
	if (f_dReg.icode == 4) {	//rm  rA,D(rB)  不需要写回寄存器
		d_eReg->srcA = f_dReg.rA;

		sel_fwda.srcA = f_dReg.rA;
		sel_fwda.register_A = Register_file[f_dReg.rA];
		SelectA_and_FwdA(&sel_fwda);
		d_eReg->valA = sel_fwda.valA;

		d_eReg->srcB = f_dReg.rB;  //对rB去寄存器取基地址
		fwdb.srcB = f_dReg.rB;
		fwdb.register_B = Register_file[f_dReg.rB];
		FwdB(&fwdb);
		d_eReg->valB = fwdb.valB;
	}
	if (f_dReg.icode == 5) {	//mr  D(rB),rA   需要验证
		d_eReg->srcB = f_dReg.rB;		//对rB去寄存器取基地址
		fwdb.srcB = f_dReg.rB;
		fwdb.register_B = Register_file[f_dReg.rB];
		FwdB(&fwdb);
		d_eReg->valB = fwdb.valB;


		d_eReg->dstM = f_dReg.rA;		//将Datamemory结果valM写回寄存器rA
	}
	if (f_dReg.icode == 6) {	//OPq rA,rB		 需要验证
		sel_fwda.srcA = f_dReg.rA;
		sel_fwda.register_A = Register_file[f_dReg.rA];
		SelectA_and_FwdA(&sel_fwda);
		d_eReg->valA = sel_fwda.valA;

		fwdb.srcB = f_dReg.rB;
		fwdb.register_B = Register_file[f_dReg.rB];
		FwdB(&fwdb);
		d_eReg->valB = fwdb.valB;

		d_eReg->dstE = f_dReg.rB;		//将ALU结果valE写回寄存器rB
	}
	if (f_dReg.icode == 7) {	//jxx     
		sel_fwda.srcA = f_dReg.rA;
		sel_fwda.register_A = Register_file[f_dReg.rA];
		SelectA_and_FwdA(&sel_fwda);
		d_eReg->valA = sel_fwda.valA;
	}
	if (f_dReg.icode == 8) {	//call
		d_eReg->srcA = 4;

		sel_fwda.srcA = 4;
		sel_fwda.register_A = Register_file[f_dReg.rA];
		SelectA_and_FwdA(&sel_fwda);
		d_eReg->valA = sel_fwda.valA;

		fwdb.srcB = 4;
		fwdb.register_B = Register_file[f_dReg.rB];
		FwdB(&fwdb);
		d_eReg->valB = fwdb.valB;

		d_eReg->dstE = 4;		//将ALU结果valE写回寄存器sp
	}
	if (f_dReg.icode == 9) {	//ret
		d_eReg->srcA = 4;				//对sp去寄存器取数据 
		sel_fwda.srcA = 4;
		sel_fwda.register_A = Register_file[f_dReg.rA];
		SelectA_and_FwdA(&sel_fwda);
		d_eReg->valA = sel_fwda.valA;

		d_eReg->srcB = 4;
		fwdb.srcB = 4;
		fwdb.register_B = Register_file[f_dReg.rB];
		FwdB(&fwdb);
		d_eReg->valB = fwdb.valB;

		d_eReg->dstE = 4;		//将ALU结果valE写回寄存器sp
	}
	if (f_dReg.icode == 0xA) {//push
		d_eReg->srcA = f_dReg.rA;

		sel_fwda.srcA = f_dReg.rA;		//对rA去寄存器取数据
		sel_fwda.register_A = Register_file[f_dReg.rA];
		SelectA_and_FwdA(&sel_fwda);
		d_eReg->valA = sel_fwda.valA;

		d_eReg->srcB = 4;
		fwdb.srcB = 4;
		fwdb.register_B = Register_file[f_dReg.rB];
		FwdB(&fwdb);
		d_eReg->valB = fwdb.valB;

		d_eReg->dstE = 4;		//将ALU结果valE写回寄存器sp
	}
	if (f_dReg.icode == 0xB) {//popq
		d_eReg->srcA = 4;				//对sp去寄存器取数据 
		sel_fwda.srcA = 4;
		sel_fwda.register_A = Register_file[f_dReg.rA];
		SelectA_and_FwdA(&sel_fwda);
		d_eReg->valA = sel_fwda.valA;

		d_eReg->srcB = 4;				//对sp去寄存器取数据
		fwdb.srcB = 4;
		fwdb.register_B = Register_file[f_dReg.rB];
		FwdB(&fwdb);
		d_eReg->valB = fwdb.valB;

		d_eReg->dstE = 4;		//将ALU结果valE写回寄存器sp
		d_eReg->dstM = f_dReg.rA;		//将Datamemory结果valM写回寄存器rA
	}
}
//执行阶段
void setCC(struct CC* cc, int a, int b, int result, int op) {
	if (op == 1) {	//OF=1   两个同符号数相加（正数+正数 或 负数+负数），结果符号与其相反。
		if ((a >= 0 && b >= 0) && result < 0) {
			cc->OF = 1;
		}
		else if ((a < 0 && b < 0) && result >= 0) {
			cc->OF = 1;
		}
		else {
			cc->OF = 0;
		}
	}
	if (op == 2) {	//OF=1 两数符号相反（正数-负数，或负数-正数），而结果符号与减数相同。
		if ((a >= 0 && b < 0) && result >= 0) {
			cc->OF = 1;
		}
		else if ((a < 0 && b >= 0) && result < 0) {
			cc->OF = 1;
		}
		else {
			cc->OF = 0;
		}
	}
	if (op == 3 || op == 4) {
		cc->OF = 0;
	}
	if (result < 0) {
		cc->SF = 1;
	}
	else {
		cc->SF = 0;
	}
	if (result) {
		cc->ZF = 1;
	}
	else {
		cc->ZF = 0;
	}
}
int ALU(int alu_a, int alu_b, int op) {
	if (op == 1)
		return alu_a + alu_b;
	else if (op == 2)
		return alu_a - alu_b;
	else if (op == 2)
		return alu_a & alu_b;
	else
		return alu_a ^ alu_b;
}
int Cond(struct CC cc, int ifunc) {
	if (ifunc == 1) {
		return (cc.SF ^ cc.OF) | cc.ZF;
	}
	if (ifunc == 2) {
		return cc.SF ^ cc.OF;
	}
	if (ifunc == 3) {
		return cc.ZF;
	}
	if (ifunc == 4) {
		return ~cc.ZF;
	}
	if (ifunc == 5) {
		return ~(cc.SF ^ cc.OF);
	}
	if (ifunc == 6) {
		return ~(cc.SF ^ cc.OF) & ~cc.ZF;
	}
}
void Excecute(struct D_EReg d_eReg, struct E_MReg* e_mReg) {
	int ALU_A;
	int ALU_B;
	e_mReg->stat = d_eReg.stat;
	e_mReg->icode = d_eReg.icode;
	e_mReg->valA = d_eReg.valA;
	e_mReg->dstM = d_eReg.dstM;
	int op = 1;//1:add,2:sub,3:and,4:xor
	if (d_eReg.icode == 0) {//				不提供数据转发
		e_mReg->dstE = 0xF;
	}
	if (d_eReg.icode == 1) {//				不提供数据转发
		e_mReg->dstE = 0xF;
	}
	if (d_eReg.icode == 2) {//rr		如果条件满足才提供数据转发
		ALU_A = d_eReg.valA;
		ALU_B = d_eReg.valB;
		op = 1;
		e_mReg->valE = ALU(ALU_A, ALU_B, op);
		fwdb.E_valE = ALU(ALU_A, ALU_B, op);
		sel_fwda.E_valE = ALU(ALU_A, ALU_B, op);
		if (d_eReg.ifuc == 0) {
			e_mReg->Cnd = 1;
		}
		if (d_eReg.ifuc == 1) {
			e_mReg->Cnd = Cond(cc, d_eReg.ifuc);
		}
		if (d_eReg.ifuc == 2) {
			e_mReg->Cnd = Cond(cc, d_eReg.ifuc);
		}
		if (d_eReg.ifuc == 3) {
			e_mReg->Cnd = Cond(cc, d_eReg.ifuc);
		}
		if (d_eReg.ifuc == 4) {
			e_mReg->Cnd = Cond(cc, d_eReg.ifuc);
		}
		if (d_eReg.ifuc == 5) {
			e_mReg->Cnd = Cond(cc, d_eReg.ifuc);
		}
		if (d_eReg.ifuc == 6) {
			e_mReg->Cnd = Cond(cc, d_eReg.ifuc);
		}
		if (e_mReg->Cnd) {
			e_mReg->dstE = d_eReg.dstE;
			fwdb.E_dstE = d_eReg.dstE;
			sel_fwda.E_dstE = d_eReg.dstE;
		}
		else {
			e_mReg->dstE = 0xF;
			fwdb.E_dstE = 0xF;
			sel_fwda.E_dstE = 0xF;
		}
	}
	if (d_eReg.icode == 3) {//ir			 提供数据转发
		op = 1;
		ALU_A = d_eReg.valC;
		ALU_B = d_eReg.valB;
		printf("执行立即数加法\n");
		e_mReg->valE = ALU(ALU_A, ALU_B, op);
		fwdb.E_valE = ALU(ALU_A, ALU_B, op);
		sel_fwda.E_valE = ALU(ALU_A, ALU_B, op);
		fwdb.E_dstE = d_eReg.dstE;
		sel_fwda.E_dstE = d_eReg.dstE;
		e_mReg->dstE = d_eReg.dstE;
	}
	if (d_eReg.icode == 4) {//rm			不提供数据转发
		op = 1;
		ALU_A = d_eReg.valC;
		ALU_B = d_eReg.valB;
		e_mReg->valE = ALU(ALU_A, ALU_B, op);
		e_mReg->dstE = 0xF;
	}
	if (d_eReg.icode == 5) {//mr			只有访存后才数据转发
		op = 1;
		ALU_A = d_eReg.valC;
		ALU_B = d_eReg.valB;
		e_mReg->valE = ALU(ALU_A, ALU_B, op);
		e_mReg->dstE = d_eReg.dstE;
	}
	if (d_eReg.icode == 6) {//Opq rr		提供数据转发
		ALU_A = d_eReg.valA;
		ALU_B = d_eReg.valB;
		e_mReg->dstE = d_eReg.dstE;
		if (d_eReg.ifuc == 0) {
			op = 1;
		}
		if (d_eReg.ifuc == 1) {
			op = 2;
		}
		if (d_eReg.ifuc == 2) {
			op = 3;
		}
		if (d_eReg.ifuc == 3) {
			op = 4;
		}
		e_mReg->valE = ALU(ALU_A, ALU_B, op);
		fwdb.E_valE = ALU(ALU_A, ALU_B, op);
		fwdb.E_dstE = d_eReg.dstE;
		fwdb.E_valE = ALU(ALU_A, ALU_B, op);
		fwdb.E_dstE = d_eReg.dstE;
		sel_fwda.E_valE = ALU(ALU_A, ALU_B, op);
		sel_fwda.E_dstE = d_eReg.dstE;
		setCC(&cc, ALU_A, ALU_B, e_mReg->valE, op);
	}
	if (d_eReg.icode == 7) {//jxx			不提供数据转发
		if (d_eReg.ifuc == 0) {				//jmp
			e_mReg->Cnd = 1;
		}
		if (d_eReg.ifuc == 1) {				//jle  (SF ^ OF) | ZF
			e_mReg->Cnd = Cond(cc, d_eReg.ifuc);
		}
		if (d_eReg.ifuc == 2) {				//jl   SF ^ OF
			e_mReg->Cnd = Cond(cc, d_eReg.ifuc);
		}
		if (d_eReg.ifuc == 3) {				//je   ZF
			e_mReg->Cnd = Cond(cc, d_eReg.ifuc);
		}
		if (d_eReg.ifuc == 4) {				//jne  ~ZF
			e_mReg->Cnd = Cond(cc, d_eReg.ifuc);
		}
		if (d_eReg.ifuc == 5) {				//jge   ~(SF ^ OF)
			e_mReg->Cnd = Cond(cc, d_eReg.ifuc);
		}
		if (d_eReg.ifuc == 6) {				//jg    ~(SF ^ OF) & ~ZF
			e_mReg->Cnd = Cond(cc, d_eReg.ifuc);
		}
	}
	if (d_eReg.icode == 8 || d_eReg.icode == 0xA) {	//call push   valB=R[%rsp]   提供数组转发
		ALU_B = d_eReg.valB;
		ALU_A = -4;							//-8
		op = 1;
		e_mReg->valE = ALU(ALU_A, ALU_B, op);
		e_mReg->dstE = d_eReg.dstE;
		fwdb.E_valE = ALU(ALU_A, ALU_B, op);
		fwdb.E_dstE = d_eReg.dstE;
		sel_fwda.E_valE = ALU(ALU_A, ALU_B, op);
		sel_fwda.E_dstE = d_eReg.dstE;
	}
	if (d_eReg.icode == 9) {	//ret   valB=R[%rsp]  提供数组转发给fwda
		ALU_B = d_eReg.valB;
		ALU_A = 4;
		op = 1;
		e_mReg->valE = ALU(ALU_A, ALU_B, op);
		e_mReg->dstE = d_eReg.dstE;
		fwdb.E_valE = ALU(ALU_A, ALU_B, op);
		fwdb.E_dstE = d_eReg.dstE;
		sel_fwda.E_valE = ALU(ALU_A, ALU_B, op);
		sel_fwda.E_dstE = d_eReg.dstE;
	}
	if (d_eReg.icode == 0xB) {	//pop  valB=R[%rsp]   提供数组转发  1.执行阶段valB=R[%rsp] 2.访存后 valM
		ALU_B = d_eReg.valB;
		ALU_A = 4;
		op = 1;
		e_mReg->valE = ALU(ALU_A, ALU_B, op);
		e_mReg->dstE = d_eReg.dstE;
		fwdb.E_valE = ALU(ALU_A, ALU_B, op);
		fwdb.E_dstE = d_eReg.dstE;
		sel_fwda.E_valE = ALU(ALU_A, ALU_B, op);
		sel_fwda.E_dstE = d_eReg.dstE;
	}
	selectpc.cnd = e_mReg->Cnd;
	selectpc.M_icode = e_mReg->icode;
}
//访存阶段
void DataMemory(int addr, int Data, int* Datamemory, int MemoryControl, struct M_WReg* m_wReg) {
	if (MemoryControl == 1) {
		m_wReg->valM = Datamemory[addr];
	}
	else if (MemoryControl == 2) {
		Datamemory[addr] = Data;
	}
}
void MemoryAccess(struct E_MReg e_mReg, struct M_WReg* m_wReg) {
	int MemoryControl = -1;	//0：不读不写;1：读有效,输入地址输出valM;2：写有效,输入地址数据
	int Addr = -1;
	int Data = -1;
	m_wReg->icode = e_mReg.icode;
	m_wReg->stat = e_mReg.stat;
	m_wReg->valE = e_mReg.valE;
	m_wReg->dstE = e_mReg.dstE;
	m_wReg->dstM = e_mReg.dstM;
	if (e_mReg.icode == 0 || e_mReg.icode == 1 || e_mReg.icode == 2) {
		MemoryControl = 0;
	}
	if (e_mReg.icode == 3 || e_mReg.icode == 8 || e_mReg.icode == 0xA) {	//rm push M[valE] = valA
		MemoryControl = 2;
		Addr = e_mReg.valE;
		Data = e_mReg.valA;
	}
	if (e_mReg.icode == 5) {	//mr
		MemoryControl = 1;
		Addr = e_mReg.valE;
	}
	if (e_mReg.icode == 9 || e_mReg.icode == 0xB) {	//ret pop M[valE] = valA
		MemoryControl = 1;
		Addr = e_mReg.valA;
	}
	//数据传递
	if (e_mReg.icode == 2 || e_mReg.icode == 3 || e_mReg.icode == 6 || e_mReg.icode == 8 || e_mReg.icode == 9
		|| e_mReg.icode == 0xA || e_mReg.icode == 0xB) {
		fwdb.M_valE = e_mReg.valE;
		fwdb.M_dstE = e_mReg.dstE;
		sel_fwda.M_valE = e_mReg.valE;
		sel_fwda.M_dstE = e_mReg.dstE;
	}
	DataMemory(Addr, Data, Datamemory, MemoryControl, m_wReg);
	if (e_mReg.icode == 5 || e_mReg.icode == 0xB) {
		fwdb.M_valM = m_wReg->valM;
		fwdb.M_dstM = e_mReg.dstM;
		sel_fwda.M_valM = m_wReg->valM;
		sel_fwda.M_dstM = e_mReg.dstM;
	}
	selectpc.M_valA = e_mReg.valA;
}
//写回阶段
void writeBack(struct M_WReg m_wReg) {
	if (m_wReg.dstE != 0xF)
		Register_file[m_wReg.dstE] = m_wReg.valE;
	if (m_wReg.dstM != 0xF)
		Register_file[m_wReg.dstM] = m_wReg.valM;
	if (m_wReg.icode == 2 || m_wReg.icode == 3 || m_wReg.icode == 6 || m_wReg.icode == 8 || m_wReg.icode == 9
		|| m_wReg.icode == 0xA || m_wReg.icode == 0xB) {
		fwdb.M_valE = m_wReg.valE;
		fwdb.M_dstE = m_wReg.dstE;
		sel_fwda.M_valE = m_wReg.valE;
		sel_fwda.M_dstE = m_wReg.dstE;
	}
	if (m_wReg.icode == 5 || m_wReg.icode == 0xB) {
		fwdb.M_valM = m_wReg.valM;
		fwdb.M_dstM = m_wReg.dstM;
		sel_fwda.M_valM = m_wReg.valM;
		sel_fwda.M_dstM = m_wReg.dstM;
	}
	selectpc.W_valM = m_wReg.valM;
	selectpc.W_icode = m_wReg.icode;
}

//主函数
int main() {
	int i = 5;
	struct F_DReg f_dReg = { 1,0,0,0,0,0,0 };
	struct D_EReg d_eReg = { 1,0,0,0,0,0,0,0,0,0 };
	struct E_MReg e_mReg = { 1,0,0,0,0,0,0 };
	struct M_WReg m_wreg = { 1,0,0,0,0xF,0xF };

	while (i--) {
		if (!selectpc.predpc) {
			Select_PC(&selectpc);
		}
		Fetch(&f_dReg, selectpc.predpc);
		printf("取指阶段-------------------\n");
		printf("f_dReg.icode = %d\n", f_dReg.icode);
		printf("f_dReg.ifun = %d\n", f_dReg.ifuc);
		printf("f_dReg.rA = %d\n", f_dReg.rA);
		printf("f_dReg.rB = %d\n", f_dReg.rB);
		printf("f_dReg.valC = %d\n", f_dReg.valC);

		Decode(f_dReg, &d_eReg, &Register_file);
		printf("译码阶段-------------------\n");
		printf("d_eReg.icode = %d\n", d_eReg.icode);
		printf("d_eReg.ifun = %d\n", d_eReg.ifuc);
		printf("d_eReg.srcA = %d\n", d_eReg.srcA);
		printf("d_eReg.valA = %d\n", d_eReg.valA);
		printf("d_eReg.srcB = %d\n", d_eReg.srcB);
		printf("d_eReg.valB = %d\n", d_eReg.valB);
		printf("d_eReg.dstE = %d\n", d_eReg.dstE);
		printf("d_eReg.dstM = %d\n", d_eReg.dstM);
		printf("d_eReg.valC = %d\n", d_eReg.valC);

		Excecute(d_eReg, &e_mReg);
		printf("执行阶段--------------------\n");
		printf("e_mReg->valE = %d\n", e_mReg.valE);
		printf("e_mReg->dstE = %d\n", e_mReg.dstE);

		MemoryAccess(e_mReg, &m_wreg);
		printf("访存阶段----------------------\n");
		writeBack(m_wreg);
		printf("写回阶段----------------------\n");
		printf("rbx = %d\n", Register_file[3]);
	}


	return 0;
}
Strive_LiJiaLe
关注
  • 2
    点赞
  • 踩
  • 22
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
Riscv五级流水线32位cpu，systemverilog编写，指令集rv32i，支持数据前递，csr寄存器与中断控制器，可跑通dhrystone测试
fTQvliYZ的博客
11-06 557
本CPU的设计使用SystemVerilog完成，这是一种常用的硬件描述语言，其拥有的高级语言特性可以很方便地实现各种硬件逻辑设计，并且还可以方便地进行模拟、仿真以及调试。在写回阶段，CPU将执行得到的结果写回到寄存器中。本CPU还支持数据前递，这是一种比较常见的技术，在CPU的结果还没有被写回到寄存器中时，可以直接从执行阶段将其结果传递到下一阶段使用，提高了CPU的效率。一般情况下，CPU可以通过分支预测来提高CPU效率，而这里的CPU支持了2bit饱和分支预测，更进一步地提高了CPU运行效率。
五级流水CPU设计五级流水CPU设计
02-01
五级流水CPU设计 流水线是数字系统中一种提高系统稳定性和工作速度的方法，广泛应用于高档CPU的架构中。根据MIPS处理器的特点，将整体的处理过程分为取指令（IF）、指令译码（ID）、执行（EX）、存储器访问（MEM）和寄存器会写（WB）五级，对应多周期的五个处理阶段。一个指令的执行需要5个时钟周期，每个时钟周期的上升沿来临时，此指令所代表的一系列数据和控制信息将转移到下一级处理.zip
RISC五级流水线CPU设计verilog仿真
最新发布
diaojiangxue的博客
03-29 844
名称：RISC_v五级流水线CPU设计verilog仿真软件：Quartus/modelsim语言：verilog本文实现的CPU是一个五级流水线的精简版CPU(也叫PCPU，即pipeline)，包括IF(取指令)、ID(解码)、EX(执行)、MEM(内存操作)、WB(回写)。指令集：RISC指令集大小：2^5 = 32数据宽度：16bit数据内存：2^8×16bit = 256个16bit指令内存：2^8×16bit = 256个16bit通用寄存器：8×16bit。
用代码描述流水线-Jenkins Pipeline 详解
weixin_41282397的博客
01-17 2653
自从 Jenkins 2.0 版本升级之后，支持了通过代码（Groovy DSL）来描述一个构建流水线，灵活方便地实现持续交付，大大提升 Jenkins Job 维护的效率，实现从 CI 到 CD 到转变。而在2016 Jenkins World 大会上，Jenkins 发布了1.0版本的声明式流水线 - Declarative Pipeline，目前已经到发布了1.2版本，它是一种新的结构化方式...
手把手教你设计大数据流水线.docx
12-17
手把手教你设计大数据流水线.docx
DevOps流水线之数据库篇
02-25
部分企业在实施DevOps过程中，发现数据库的升级成为企业DevOps流水线上的核心瓶颈，应用程序发布频率越来越快，但是数据库依然采用手工更新的方式，导致数据库升级效率低下、风险较大。所以建立一套完整的应用+数据库的DevOps流水线是至关重要的。接下来小编将带大家手把手搭建一套基于TeamFoundationServer的数据库CI、CD流水线。基于数据库升级\迁移脚本：采用像编写应用代码一样的方式去编写数据库升级脚本，对脚本文件进行顺序编号并迁入代码库，在持续发布阶段按照编号依次顺序执行数据库升级脚本。完成数据库的升级\变更动作。可以使用Flyway,Evolve,Liquebase等工具
MIPS五级流水线CPU（全部注释）
04-28
系统硬件综合设计 设计并实现一个多周期和流水CPU。 1.若干段流水、可以处理冲突。 2.三种类型的指令（R类，I类，J类指令）若干条。 3.CPU指令集（MIPS、ARM、RISC-V等均可）不限
MIPS-5级流水线CPU
weixin_43877853的博客
12-31 1万+
一、流水线CPU 流水线CPU就是指将一条分解为多步，在同一周期内进行多条指令的同时执行。MIPS五级流水线就是将指令分为：取指(IF)，译码(ID)，执行(EX)，访存(MEM)，写回(WB)五个阶段。举个例子： 比如第二条指令lui $t2,0x2100 在流水线CPU中执行的就是 可以看到在200-300ns的周期里，IF阶段取到0x00400004处的指令，300-400ns，这条指令到了ID阶段，而IF阶段执行下一条指令。400-500ns，执行这条指令，ALU的结果为0x2100
Jenkins + Gitlab 实现代码流水线部署
weixin_56301040的博客
05-18 4483
DevOps DevOps 概述 DevOps（Development和Operations的组合词）是一种重视 “ 软件开发人员（Dev）” 和 “ IT运维技术人员（Ops）”之间沟通合作的文化、运动或惯例； 通过自动化“软件交付”和“架构变更”的流程，来使得构建、测试、发布软件能够更加地快捷、频繁和可靠 DevOps 平台 代码托管 --- Gitlab、SVN 项目管理 --- Jira、Teambition、禅道 运维平台 --- 腾讯蓝鲸、自主研发平台 持续交付
CICD流水线（发布后端代码）！！！
qq_64847107的博客
03-22 284
1、Docker部署。
【Verilog项目】计算机体系结构-五级流水线CPU
weixin_45151415的博客
02-28 2482
本文涉及实验是电子科技大学2021计算机体系结构课程实验。内容均为原创
手把手教您构建自己的DevOps流水线
02-23
导读：DevOps是一套实践方法，在保证高质量的前提下缩短系统变更从提交到部署至生产环境的时间，其中持续集成和持续交付是DevOps里面非常重要的一环。本文讲述了达到自动化持续交付需要做的准备工作，流水线构建方法和最佳实践。持续交付是一组能够帮助软件开发团队极大的提高其软件交付的速度和质量的模式和最佳实践组成。不同于低频率发布相对较大的版本，实施持续交付的团队希望比通常更频繁地将更小批量的变更投入生产，例如每周，每天或一天之内就能够发布多个版本。这种软件交付方式可以带来许多的好处，就像市场领导者Facebook，LinkedIn和Twitter那样，他们频繁地，以迭代方式发布软件，并取得了巨大
手把手教您构建自己的 DevOps 流水线
01-26
导读：DevOps 是一套实践方法，在保证高质量的前提下缩短系统变更从提交到部署至生产环境的时间，其中持续集成和持续交付是 DevOps 里面非常重要的一环。本文讲述了达到自动化持续交付需要做的准备工作，流水线构建方法和最佳实践。
MIPS五级流水线CPU(verilog实现)
12-07
计算机组成原理课程实验：一个MIPS五级流水线CPU 内含全部源代码和实验文档，verilog实现，开发平台为ISE
自己动手写CPU之第五阶段（1）——流水线数据相关问题
leishangwen的专栏
07-30 1万+
我们在第4章实现的五级流水线结构很简单，如果按照“简单即美（Simple is Beautiful）的标准，那么我们的流水线是美的，但是不完美，因为现实往往是复杂的，一个简单的流水线是解决不了如此多的现实问题的，本节探讨的数据相关问题就是其中一个问题。在我们实现逻辑、移位操作等其它指令之前，必须先讨论这个问题，因为这个问题已经影响到测试程序的编写了。 流水线中经常有一些被称为“相关”的情况发生，它使得指令序列中下一条指令无法按照设计的时钟周期执行，这些“相关”会降低流水线的性能。流水线中的相关分为三种类型。
C语言 n的作业,C语言之流水线作业问题
weixin_39944638的博客
05-16 652
对于流线作业问题假设有n个作业和m台机器，每台机器每一刻只能做一个作业，每个作业完成需不同的时间。问题：编写一个程序使得n个作业在m台机器上工作时间最少？分析：分两种情况：1.n<=m：n个作业直接分配给m台机器2.n>m:将n中作业中的m个时间最长的分配给m台机器，然后依次选其完成时间最早的机器继续执行剩余的作业，直到所有作业完成即可。具体代码如下：#includeint t[200...
C/C++ 流水线 缓存以及优化
a727674650的博客
11-10 2111
抄书笔记 《游戏引擎架构》第二版 游戏是软实时系统。软实时系统是指游戏软件必须在限期内完成操作——游戏中最显然的需求是没帧必须在16.6ms（以达到60FPS）或者33.3ms（以达到30FPS）内完成。软的部分是指没有人会因为帧率而死亡（相对医疗和交通系统的硬实时系统，如果不能在有限的时间内完成操作可能导致严重意外）。尽管如此，无需怀疑，游戏需要尽可能的高效运行。 一 并行范式转移 优化软件的性能，就要了解什么使软件变慢。 在早期计算机中，CPU相对较慢，因此程序员在优化代码的过程中，会集中降低任务所花费
C++流水线的简易实现
WangIcter的专栏
07-02 1万+
流水线本来是工程任务中为了将不同的工序分开的一种处理流程。这种分工，会给工作的流程化和吞吐带来一定的好处。 如果将流水线应用到程序中，会有如下一些好处： 1、不需要锁。线程之间有时序关系，因此从流程设计上就规避了锁的机制； 2、多线程并发。不同线程负责不同的事务处理，可以在一定程度上实现并发； 3、吞吐量高。由于多线程不会像单线程那样阻塞，所以吞吐量会有一定提高。 但流水线也有它的缺点：...
持续集成+自动化部署[代码流水线管理及Jenkins和gitlab集成]
热门推荐
i4t abcdocker的博客
12-23 2万+
持续集成+自动化部署[代码流水线管理及Jenkins和gitlab集成]标签（空格分隔）： Jenkins一、代码流水线管理　　Pipeline名词顾名思义就是流水线的意思，因为公司可能会有很多项目。如果使用jenkins构建完成后，开发构建项目需要一项一项点击，比较麻烦。所以出现pipeline名词。 　　代码质量检查完毕之后，我们需要将代码部署到测试环境上去，进行自动化测试新建部署代码项目
手把手教你设计cpu——risc-v处理器篇
06-28
### 回答1： 很高兴听到您对RISC-V处理器的兴趣。设计CPU是一项复杂的任务，需要深入的计算机体系结构知识和硬件设计技能。以下是一些基本步骤，可以帮助您开始设计RISC-V处理器： 1.了解RISC-V架构：RISC-V是一种开放源代码指令集架构，它的设计旨在简化处理器的设计和实现。您需要了解RISC-V的指令集、寄存器、内存管理和异常处理等方面的基本知识。 2.选择设计工具：设计CPU需要使用硬件描述语言（HDL），如Verilog或VHDL。您需要选择一个合适的设计工具，如Xilinx Vivado或Altera Quartus等。 3.设计处理器核心：处理器核心是CPU的主要组成部分，它包括指令译码、执行单元、寄存器文件和数据通路等。您需要根据RISC-V架构的要求设计处理器核心。 4.实现内存管理单元：内存管理单元（MMU）是处理器的重要组成部分，它负责管理内存访问和虚拟地址转换等。您需要实现MMU以支持RISC-V的内存管理功能。 5.测试和验证：设计CPU后，您需要进行测试和验证以确保其正确性和性能。您可以使用仿真工具进行测试，或者使用FPGA进行验证。 以上是设计RISC-V处理器的基本步骤，但这只是一个简单的概述。设计CPU需要深入的计算机体系结构知识和硬件设计技能，需要不断学习和实践。希望这些信息能够帮助您开始设计RISC-V处理器。 ### 回答2： RISC-V处理器是一款开源的指令集架构，目前被广泛应用于各种类型的芯片设计中，如移动设备、网络设备、服务器等。在学习如何设计RISC-V处理器之前，我们需要先了解一些基本的概念和技术。 首先，指令集架构（ISA）是处理器硬件和软件之间通信的接口规范，决定了处理器可以解释和执行哪些指令。在RISC-V处理器中，指令集被分为不同的“指令集扩展”模块，包括基本指令集、乘除运算指令集、浮点运算指令集等。每个扩展模块都包含一组相关的指令，为定制和优化处理器提供了灵活性。 其次，流水线技术是处理器设计中常用的性能优化手段。流水线是一个分阶段的处理器执行单元，每个阶段依次执行指令的不同部分，从而实现指令并行执行。然而，流水线可能会遇到数据相关性和控制相关性等问题，需要使用一些技术来解决。 最后，硬件描述语言（HDL）是描述数字电路和系统的语言，可以使用HDL来描述处理器的逻辑电路和功能实现。常见的HDL包括Verilog和VHDL，可以使用这些语言来实现RISC-V处理器的功能模块。 接下来，我们可以手把手教你如何设计RISC-V处理器： 第一步，定义指令集。定义指令集是设计处理器的第一步，需要确定基本指令集并考虑扩展模块的需求。 第二步，确定处理器流水线架构。处理器流水线架构的设计涉及指令的分阶段执行和数据通路的设计，需要考虑处理器性能和复杂度的平衡。 第三步，实现处理器的逻辑电路。通过HDL语言来实现RISC-V处理器的逻辑电路和功能模块，包括控制单元、寄存器文件和运算单元等。 第四步，进行仿真和验证。仿真和验证是测试处理器功能和性能的关键步骤，可以使用EDA工具来进行仿真和验证。 第五步，进行物理设计。物理设计涉及到处理器芯片的物理规划、布图和布线等步骤，需要协同进行。 以上是大致的设计流程，实际上，RISC-V处理器设计需要考虑的因素还有很多，例如内存管理、中断处理等等。不过，只要按照步骤逐步设计，加上充分的沟通和协作，基本上都能够顺利完成设计任务。 ### 回答3： RISC-V是一个完全开源的指令集架构，可以自由使用和修改，非常适合自己设计CPU。以下是手把手教你设计CPU-RISC-V处理器篇。 第一步：确定CPU体系结构和指令集 首先，需要确定CPU的体系结构和指令集。RISC-V提供了多个不同级别的指令集，每个级别的指令集都有不同的指令数量、复杂度和性能。根据自己的需要和能力，选择适合自己的指令集。 第二步：设计CPU数据通路 设计CPU的数据通路需要确定如何实现指令的执行和数据的传输。可以使用硬件描述语言（例如Verilog）来描述数据通路。对于RISC-V处理器，需要实现以下基本单元：ALU（算术逻辑单元）、寄存器文件、存储器控制器和指令解码器。 第三步：测试CPU 设计完成后，需要对CPU进行测试。可以使用模拟器来模拟CPU的运行，也可以将CPU制成芯片进行实际测试。在测试期间，可以使用不同的指令和数据来验证CPU的正确性和性能。 第四步：优化CPU 一旦确认CPU能够正确运行，就可以开始优化CPU的性能。可以使用一些技术来提高CPU的性能和功效，例如通过流水线、分支预测、数据缓存等方式提高数据传输和处理效率。 总结： 设计RISC-V处理器需要确定体系结构和指令集，设计数据通路，测试和优化。这个过程需要深厚的计算机体系结构和数字电路设计的知识，同时要有足够的耐心和毅力。通过这个过程，可以获得极为满足和有成就感的终极收获。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

Strive_LiJiaLe

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值