bupt 大作业C语言 ——冯诺依曼式CPU模拟器

最新推荐文章于 2023-02-28 19:02:04 发布
最新推荐文章于 2023-02-28 19:02:04 发布
阅读量269 收藏
点赞数
分类专栏： 笔记 文章标签： c语言 编程语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/o_xy_ge_n/article/details/118633913
版权

bupt 大作业C语言 ——冯诺依曼式CPU模拟器

/*
作者：bupt
时间：2021.7.10

主函数main
 1>取指令，保存到寄存器
 2>分析指令，执行指令
 3>输出代码，数据 
 
代码 code [] 
数据 data [] 
指令 寄存器 ir 	前 16位 
程序 寄存器 ip 	+4 
标志 寄存器 flag   		       （程序计数器 
4个数据 寄存器 ax1 暂时粗存 
4个地址 寄存器 ax5 存放位置，eg：16384->0 
ax[i]  第 i 个寄存器 
*/
————————————————————————————
#include <stdio.h>
#include <stdlib.h>

void read_in_opcode(char code[]);//读入函数
void analyse(char code[],int data[],int ax[],int *ip,int *flag,int *ir);//分析指令并进行操作
void output_function(int *ip,char code[],int data[]);//输出函数 
int binary(char code[],int start,int n);//二进制转十进制 (code 为代码段，start为从什么时候开始翻译，n转换位数）
int cut(int num);//剪切函数，剪切多余部分 （处理溢出数据）


void task1_teleport(int front,int back,int immediate_count,int data[],int ax[]);//数据传输指令 
void task2_calculate_plus(int front,int back,int immediate_count,int data[],int ax[]);//计算加指令 
void task3_calculate_minus(int front,int back,int immediate_count,int data[],int ax[]);//计算减指令 
void task4_calculate_times(int front,int back,int immediate_count,int data[],int ax[]);//计算乘指令 
void task5_calculate_divise(int front,int back,int immediate_count,int data[],int ax[]);//计算整除指令 
void task6_logical_and(int front,int back,int immediate_count,int data[],int ax[]);//逻辑与指令 
void task7_logical_or(int front,int back,int immediate_count,int data[],int ax[]);//逻辑或指令 
void task8_logical_non(int front,int back,int immediate_count,int data[],int ax[]);//逻辑非指令 
void task9_compare(int front,int back,int immediate_count,int data[],int ax[],int *flag);//比较指令
void task10_jump(int front,int back,int immediate_count,int *ip,int *flag);//跳转指令
void task11_input(int front,int ax[],int data[]);//输入指令
void task12_output(int front,int ax[],int data[]);//输出指令 



int main(int argc, char *argv[])
{	
	char code[16400]={0};//代码段（输入的指令） 
	int data[32800]={0};//数据段
	int ax[9]={0};//前四个数据寄存器，后四个地址寄存器 
	int ip=0;//程序计数器
	int flag=0;//标志寄存器
	int ir=0;//指令寄存器

	read_in_opcode(code);//读取指令
	analyse(code,data,ax,&ip,&flag,&ir);//分析指令并进行操作 
	output_function(&ip,code,data);//输出 
	return 0;
}

//将文件中的指令读入 
void read_in_opcode(char code[])//读入函数
{
	int i=0;
	FILE *fPtr=fopen("dict.dic","r") ;
	for(i=0;!feof(fPtr);i++)
	{
		code[i]=getc(fPtr);
	}
} 


void analyse(char code[],int data[],int ax[],int *ip,int *flag,int *ir)//分析指令并进行操作
{
	int i,start;
	int task=1,front_antecedent_instruction,back_post_instruction,immediate_count;
	while (task>=1&&task<=12)
	{
		start=(*ip)/4*33;
		task=binary(code,start,8);
		start=(*ip)/4*33+8;
		front_antecedent_instruction=binary(code,start,4);
		start=(*ip)/4*33+12;
		back_post_instruction=binary(code,start,4);
		start=(*ip)/4*33+16;
		immediate_count=binary(code,start,16);
		
		*ip=(*ip)+4;//标志寄存器 
		*ir=task*256+front_antecedent_instruction*16+back_post_instruction;//指令寄存器更新 
		
		//接下来进行操作 
		switch(task)
		{
			case 1:
				task1_teleport(front_antecedent_instruction,back_post_instruction,immediate_count,data,ax);
				break;
			case 2:
				task2_calculate_plus(front_antecedent_instruction,back_post_instruction,immediate_count,data,ax);
				break;
			case 3:
				task3_calculate_minus(front_antecedent_instruction,back_post_instruction,immediate_count,data,ax);
				break;
			case 4:
				task4_calculate_times(front_antecedent_instruction,back_post_instruction,immediate_count,data,ax);
				break;
			case 5:
				task5_calculate_divise(front_antecedent_instruction,back_post_instruction,immediate_count,data,ax);
				break;
			case 6:
				task6_logical_and(front_antecedent_instruction,back_post_instruction,immediate_count,data,ax);
				break;
			case 7:
				task7_logical_or(front_antecedent_instruction,back_post_instruction,immediate_count,data,ax);
				break;
			case 8:
				task8_logical_non(front_antecedent_instruction,back_post_instruction,immediate_count,data,ax);
				break;
			case 9:
				task9_compare(front_antecedent_instruction,back_post_instruction,immediate_count,data,ax,flag);
				break;
			case 10:
				task10_jump(front_antecedent_instruction,back_post_instruction,immediate_count,ip,flag);
				break;
			case 11:
				task11_input(front_antecedent_instruction,ax,data);
				break;
			case 12:
				task12_output(front_antecedent_instruction,ax,data);
				break;
			default:
				break;
		} 
		
		
		printf("ip = %d\nflag = %d\nir = %d\n",*ip,*flag,*ir);
		for (i=1;i<=4;i++)
		{
			printf("ax%d = %d ",i,ax[i]);
		}
		printf("\n");
		for(i=5;i<=8;i++)
		{
			printf("ax%d = %d ",i,ax[i]);
		}
		printf("\n");
		
		/*
		printf("\ntask:%d\n",task);
		
		printf("\ndataSegment :\n");
		int count=0;
		for(i=0;i<16*16;i++)
		{
			printf("%d ",data[i]);
			count++;
			if(count%16==0)
			printf("\n");
		}*/
	}
}

int binary(char code[],int start,int n)//二进制转十进制 (code 为代码段，start为从什么时候开始翻译，n转换位数）
{
	int sum,i;
	sum=0;
	for (i=start;i<start+n;i++)
	{
		sum=sum*2+(code[i]-'0');
	}
	
	if(n==16)
	{
		if(sum>32767)
			sum=sum-65536;
	}
	return sum;
}

int cut(int num)
{
	num=num%65536;
	if(num>32767)
		num=num-65536;
	if(num<-32767)
		num=65536+num;
	return num;
} 

void output_function(int *ip,char code[],int data[])//输出函数 
{
	int count,flag1,start,i;
	flag1=1;
	count=0;
	*ip=0;
	printf("\ncodeSegment :\n");
	while (flag1!=0)
	{
		start=(*ip)/4*33;
		flag1=binary(code,start,32);
		printf("%d ",flag1);
		*ip=(*ip)+4;
		count++;
		if(count%8==0)
			printf("\n");
	}
	for(i=16*8-count;i>0;i--){
		printf("0 ");
		count++;
		if(count%8==0)
			printf("\n");
	} 
	
	printf("\ndataSegment :\n");
	count=0;
	for(i=0;i<16*16;i++)
	{
		printf("%d ",data[i]);
		count++;
		if(count%16==0)
			printf("\n");
	} 
}

void task1_teleport(int front,int back,int immediate_count,int data[],int ax[])//数据传输指令
{
	if(back==0)
	{ 
		ax[front]=immediate_count;
	}
	else if(back<=4)
	{
		if(front>4)
			data[(ax[front]-16384)/2]=ax[back]; 
		else if(front<=4)
			ax[front]=ax[back];
	} 
	else if(back>4)
	{	
		if(front<=4)
			ax[front]=data[(ax[back]-16384)/2];
		else if(front>4)
			data[(ax[front]-16384)/2]=data[(ax[back]-16384)/2];
	}
} 


void task2_calculate_plus(int front,int back,int immediate_count,int data[],int ax[])//计算加指令
{
	if(back==0)
	{	
		if(front<=4)
		{
			ax[front]+=immediate_count;
			ax[front]=cut(ax[front]);
		}

		else if(front>4)
		{
			data[(ax[front]-16384)/2]+=immediate_count;
			data[(ax[front]-16384)/2]=cut(data[(ax[front]-16384)/2]);	
		}
	}
	else if(back>4)
		{
			if(front<=4){
				ax[front]+=data[(ax[back]-16384)/2];
				ax[front]=cut(ax[front]);
			}
			else if(front>4){
				data[(ax[front]-16384)/2]+=data[(ax[back]-16384)/2];
				data[(ax[front]-16384)/2]=cut(data[(ax[front]-16384)/2]);
			}
		}
	else if(back<=4)
		{
			if(front<=4){
				ax[front]+=ax[back];
				ax[front]=cut(ax[front]);
			}
			else if (front>4){
				data[(ax[front]-16384)/2]+=ax[back];
				data[(ax[front]-16384)/2]=cut(data[(ax[front]-16384)/2]);
			}

		}
} 


void task3_calculate_minus(int front,int back,int immediate_count,int data[],int ax[])//计算减指令 
{
	if(back==0)
	{	
		if(front<=4)
		{
			ax[front]-=immediate_count;
			ax[front]=cut(ax[front]);
		}

		else if(front>4)
		{
			data[(ax[front]-16384)/2]-=immediate_count;
			data[(ax[front]-16384)/2]=cut(data[(ax[front]-16384)/2]);	
		}
	}
	else if(back>4)
		{
			if(front<=4){
				ax[front]-=data[(ax[back]-16384)/2];
				ax[front]=cut(ax[front]);
			}
			else if(front>4){
				data[(ax[front]-16384)/2]-=data[(ax[back]-16384)/2];
				data[(ax[front]-16384)/2]=cut(data[(ax[front]-16384)/2]);
			}
		}
	else if(back<=4)
		{
			if(front<=4){
				ax[front]-=ax[back];
				ax[front]=cut(ax[front]);
			}
			else if (front>4){
				data[(ax[front]-16384)/2]-=ax[back];
				data[(ax[front]-16384)/2]=cut(data[(ax[front]-16384)/2]);
			}

		}
} 


void task4_calculate_times(int front,int back,int immediate_count,int data[],int ax[])//计算乘指令 
{
	if(back==0)
	{	
		if(front<=4)
		{
			ax[front]*=immediate_count;
			ax[front]=cut(ax[front]);
		}

		else if(front>4)
		{
			data[(ax[front]-16384)/2]*=immediate_count;
			data[(ax[front]-16384)/2]=cut(data[(ax[front]-16384)/2]);	
		}
	}
	else if(back>4)
		{
			if(front<=4){
				ax[front]*=data[(ax[back]-16384)/2];
				ax[front]=cut(ax[front]);
			}
			else if(front>4){
				data[(ax[front]-16384)/2]*=data[(ax[back]-16384)/2];
				data[(ax[front]-16384)/2]=cut(data[(ax[front]-16384)/2]);
			}
		}
	else if(back<=4)
		{
			if(front<=4){
				ax[front]*=ax[back];
				ax[front]=cut(ax[front]);
			}
			else if (front>4){
				data[(ax[front]-16384)/2]*=ax[back];
				data[(ax[front]-16384)/2]=cut(data[(ax[front]-16384)/2]);
			}

		}
} 


void task5_calculate_divise(int front,int back,int immediate_count,int data[],int ax[])//计算整除指令 
{
	if(back==0)
	{	
		if(front<=4)
		{
			ax[front]/=immediate_count;
			ax[front]=cut(ax[front]);
		}

		else if(front>4)
		{
			data[(ax[front]-16384)/2]/=immediate_count;
			data[(ax[front]-16384)/2]=cut(data[(ax[front]-16384)/2]);	
		}
	}
	else if(back>4)
		{
			if(front<=4){
				ax[front]/=data[(ax[back]-16384)/2];
				ax[front]=cut(ax[front]);
			}
			else if(front>4){
				data[(ax[front]-16384)/2]/=data[(ax[back]-16384)/2];
				data[(ax[front]-16384)/2]=cut(data[(ax[front]-16384)/2]);
			}
		}
	else if(back<=4)
		{
			if(front<=4){
				ax[front]/=ax[back];
				ax[front]=cut(ax[front]);
			}
			else if (front>4){
				data[(ax[front]-16384)/2]/=ax[back];
				data[(ax[front]-16384)/2]=cut(data[(ax[front]-16384)/2]);
			}

		}
} 


void task6_logical_and(int front,int back,int immediate_count,int data[],int ax[])//逻辑与指令 
{
	if(back==0)
	{
		if(front<=4)
		{
			int a;
			if (ax[front]<0)
				a=ax[front]+65536;
			else
				a=ax[front];
				
			if ((a&immediate_count)==0)
				ax[front]=0;
			else
				ax[front]=1;
		}
		else if (front>4)
		{
			int a;
			if (data[(ax[front]-16384)/2]<0)
				a=data[(ax[front]-16384)/2]+65536;
			else 
				a=data[(ax[front]-16384)/2];
			if((a&immediate_count)==0)
				data[(ax[front]-16384)/2]=0;
			else
				data[(ax[front]-16384)/2]=1;
		}

	}
	else if(back<=4)
	{
		if(front<=4)
		{
			int a;
			if (ax[front]<0)
				a=ax[front]+65536;
			else
				a=ax[front];
			int b;
			if (ax[back]<0)
				b=ax[back]+65536;
			else
				b=ax[back];
				
			if((a&b)==0)
				ax[front]=0;
			else
				ax[front]=1;
		}
		else if(front>4)
		{
			int a;
			if (data[(ax[front]-16384)/2]<0)
				a=data[(ax[front]-16384)/2]+65536;
			else 
				a=data[(ax[front]-16384)/2];
				
			int b;
			if (ax[back]<0)
				b=ax[back]+65536;
			else
				b=ax[back];
				
			if((a&b)==0)
				data[(ax[front]-16384)/2]=0;
			else 
				data[(ax[front]-16384)/2]=1;
		}
	}
	else if(back>4)
	{
		if(front<5)
		{
			int a;
			if (ax[front]<0)
				a=ax[front]+65536;
			else
				a=ax[front];
			
			int b;
			if (data[(ax[back]-16384)/2]<0)
				b=data[(ax[back]-16384)/2]+65536;
			else 
				b=data[(ax[back]-16384)/2];
				
			if((a&b)==0)
				ax[front]=0;
			else
				ax[front]=1;
		}
		else if (front>4)
		{
			int a;
			if (data[(ax[front]-16384)/2]<0)
				a=data[(ax[front]-16384)/2]+65536;
			else 
				a=data[(ax[front]-16384)/2];
				
			int b;
			if (data[(ax[back]-16384)/2]<0)
				b=data[(ax[back]-16384)/2]+65536;
			else 
				b=data[(ax[back]-16384)/2];
			
			if((a&b)==0)
				data[(ax[front]-16384)/2]=0;
			else
				data[(ax[front]-16384)/2]=1;
		}
	}
}


void task7_logical_or(int front,int back,int immediate_count,int data[],int ax[])//逻辑或指令 
{
	if(back==0)
	{
		if(front<=4)
		{
			int a;
			if (ax[front]<0)
				a=ax[front]+65536;
			else
				a=ax[front];
			if ((a|immediate_count)==0)
				ax[front]=0;
			else
				ax[front]=1;
		}
		else if (front>4)
		{
			int a;
			if (data[(ax[front]-16384)/2]<0)
				a=data[(ax[front]-16384)/2]+65536;
			else 
				a=data[(ax[front]-16384)/2];
			if((a|immediate_count)==0)
				data[(ax[front]-16384)/2]=0;
			else
				data[(ax[front]-16384)/2]=1;
		}

	}
	else if(back<=4)
	{
		if(front<=4)
		{
			int a;
			if (ax[front]<0)
				a=ax[front]+65536;
			else
				a=ax[front];
				
			int b;
			if (ax[back]<0)
				b=ax[back]+65536;
			else
				b=ax[back];
				
			if((a|b)==0)
				ax[front]=0;
			else
				ax[front]=1;
		}
		else if(front>4)
		{
			int a;
			if (data[(ax[front]-16384)/2]<0)
				a=data[(ax[front]-16384)/2]+65536;
			else 
				a=data[(ax[front]-16384)/2];
				
			int b;
			if (ax[back]<0)
				b=ax[back]+65536;
			else
				b=ax[back];
				
			if((a|b)==0)
				data[(ax[front]-16384)/2]=0;
			else 
				data[(ax[front]-16384)/2]=1;
		}
	}
	else if(back>4)
	{
		if(front<5)
		{
			int a;
			if (ax[front]<0)
				a=ax[front]+65536;
			else
				a=ax[front];
			
			int b;
			if (data[(ax[back]-16384)/2]<0)
				b=data[(ax[back]-16384)/2]+65536;
			else 
				b=data[(ax[back]-16384)/2];
				
			if((a|b)==0)
				ax[front]=0;
			else
				ax[front]=1;
		}
		else if (front>4)
		{
			int a;
			if (data[(ax[front]-16384)/2]<0)
				a=data[(ax[front]-16384)/2]+65536;
			else 
				a=data[(ax[front]-16384)/2];
				
			int b;
			if (data[(ax[back]-16384)/2]<0)
				b=data[(ax[back]-16384)/2]+65536;
			else 
				b=data[(ax[back]-16384)/2];
			
			if((a|b)==0)
				data[(ax[front]-16384)/2]=0;
			else
				data[(ax[front]-16384)/2]=1;
		}
	}
}


void task8_logical_non(int front,int back,int immediate_count,int data[],int ax[])//逻辑非指令 
{
	if(front==0)
	{
		if(back>4)
		{
			if((!data[(ax[back]-16384)/2])==0)
				data[(ax[back]-16384)/2]=0;
			else
				data[(ax[back]-16384)/2]=1;
		}
		else if (back<=4)
		{
			if(!ax[back]==0)
				ax[back]=0;
			else
				ax[back]=1;
		}
	}
	else if(back==0)
	{
		if(front<=4)
		{
			if((!ax[front])==0)
				ax[front]=0;
			else
				ax[front]=1;
		}
		else if(front>4)
		{
			if((!data[(ax[front]-16384)/2])==0)
				data[(ax[front]-16384)/2]=0;
			else
				data[(ax[front]-16384)/2]=1;
		}
	}
}


void task9_compare(int front,int back,int immediate_count,int data[],int ax[],int *flag)//比较指令
{
	if(back==0)
	{
		if(front<=4)
		{
			if(ax[front]>immediate_count)
				*flag=1;
			if(ax[front]==immediate_count)
				*flag=0;
			if(ax[front]<immediate_count)
				*flag=-1;
		}
		else if (front>4)
		{
			if(data[(ax[front]-16384)/2]>immediate_count)
				*flag=1;
			if(data[(ax[front]-16384)/2]==immediate_count)
				*flag=0;
			if(data[(ax[front]-16384)/2]<immediate_count)
				*flag=-1;
		}
	}
	else if(back<=4)
	{
		if (front<=4)
		{
			if(ax[front]>ax[back])
				*flag=1;
			if(ax[front]==ax[back])
				*flag=0;
			if(ax[front]<ax[back])
				*flag=-1;
		}
		else if(front>4)
		{
			if(data[(ax[front]-16384)/2]>ax[back])
				*flag=1;
			if(data[(ax[front]-16384)/2]==ax[back])
				*flag=0;
			if(data[(ax[front]-16384)/2]<ax[back])
				*flag=-1;
		}
	}
	else if(back>4)
	{
		if (front<=4)
		{
			if(ax[front]>data[(ax[back]-16384)/2])
				*flag=1;
			if(ax[front]==data[(ax[back]-16384)/2])
				*flag=0;
			if(ax[front]<data[(ax[back]-16384)/2])
				*flag=-1;
		}
		else if(front>4)
		{
			if(data[(ax[front]-16384)/2]>data[(ax[back]-16384)/2])
				*flag=1;
			if(data[(ax[front]-16384)/2]==data[(ax[back]-16384)/2])
				*flag=0;
			if(data[(ax[front]-16384)/2]<data[(ax[back]-16384)/2])
				*flag=-1;
		}
	}
}


void task10_jump(int front,int back,int immediate_count,int *ip,int *flag)//跳转指令
{
	if(back==0)
	{
		*ip=*ip+immediate_count-4;
	}
	if(back==1)
	{
		if(*flag==0)
			*ip=*ip+immediate_count-4;
	}
	if(back==2)
	{
		if(*flag==1)
			*ip=*ip+immediate_count-4;
	}
	if(back==3)
	{
		if(*flag==-1)
			*ip=*ip+immediate_count-4;
	}
}


void task11_input(int front,int ax[],int data[])//输入指令
{
	printf("in:\n");
	if(front<=4)
		scanf("%d",&ax[front]);
	else 
		scanf("%d",&data[(ax[front]-16384)/2]);
}

void task12_output(int front,int ax[],int data[])//输出指令
{
	printf("out: ");
	if(front<=4)
		printf("%d\n",ax[front]);
	else
		printf("%d\n",data[(ax[front]-16384)/2]);
}

该代码通过北邮oj 4个测试。

实用工具：
北邮19级大作业CPU模拟器指令生成及执行工具.

jray的测试用例

文本对比网站

o_xy_ge_n
关注
专栏目录
BUPT计导课设：冯诺依曼式计算机CPU模拟器
YYDS_me2002的博客
02-19 813
冯诺依曼式计算机CPU模拟器 任务：模拟一个简易的冯诺依曼式计算机CPU的工作。 该CPU字长为16位，共11个寄存器，其中3个系统寄存器，分别为程序计数器，指令寄存器，标志寄存器；8个通用寄存器，即寄存器1、2、3、4（数据寄存器），寄存器5、6、7、8（地址寄存器）。该CPU至多支持32K内存。内存分两部分，一部分为代码段，从地址0开始。另一部分为数据段，从地址16384开始。 单核code（部分）： #include<bits/stdc++.h> #define CMD_LEN 32 //
datalink_BUPT_计网大作业_滑动窗口协议_
09-29
在这个“datalink_BUPT_计网大作业_滑动窗口协议_”的压缩包中，我们可以看到一个名为“datalink.c”的源代码文件，这很可能是北邮大学计算机网络课程的一个实践项目，要求学生实现滑动窗口协议。 滑动窗口协议的...
模拟CPU算术运算的C语言代码
04-22
除了在必要的循环中使用了加法以外，只使用位操作（逻辑与或异或，移位等）模拟CPU的算术运算过程，支持整数与浮点的四则运算，包含字符串与浮点数的转换。
c语言模拟cpu大作业,C语言实现时间片轮转法的cpu调度模拟
weixin_42452244的博客
05-16 250
/*小弟初出茅庐，菜鸟一个，各路大神请多指教。*//*这是实验课题目，上课时写的，不是很完整，仅当留着做个纪念，有问题大家一起学习讨论。*//*第一次发博客，哈哈，挺乐的。废话不多说，直接上代码！*//*****时间片轮转法进行CPU调度算法********/#include#include#include#defineN10//定义最大进程数#defineTIME2//定义时间片大...
C语言简单模拟CPU调度算法（FCFS,SJF,HRRF,RR）
一只懒猫的博客
11-08 7271
文章目录一、处理器调度算法简介1、概念解释2、产生原因3、算法优劣性的指标资源利用率：吞吐率：公平性：作业周转时间：二、代码总体思路二、先来先服务（First Come First Serve，FCFS）算法思想：具体代码三、短作业优先（Short Job First，SJF）算法思想代码实现四、高响应比优先（High Response Ratio First，HRRF）算法思想具体实现五、时间片轮转算法（Round-Robin scheduling，RR）算法思想具体实现六、完整项目链接 在学OS的时候，
C++模拟CPU
MrLuo8的博客
10-27 687
Computer.cpp #include <iostream> #include "CPU.cpp" #include "Memory.cpp" using namespace std; class Computer { private: CPU cpu; Memory memory; public: Computer() { cout << "Computer constructor 1 begins to be called ..." << endl;
C模拟CPU & 内存——《如何编写计算机模拟器》选节
fredzzt的专栏
01-14 2443
一、如何模拟一个 CPU？ 首先，如果你需要模拟一个标準的 Z80 或 6502 CPU，你可以使用 Marat Fayzullin 所写的 CPU 模拟器 当然有些限制。 对那些想要自己写 CPU 模拟核心，或是对其中的运作原理感性趣的人，我提供一个用 C 写的范例架构如下，在真正的实做，你或许会考虑略过其中部份，或添加新的部份。 1 2 3
BUPT大一时候写的的c语言大作业 选课系统.zip
最新发布
08-06
相关项目设计中，皆可应用在项目开发、毕业设计、课程设计、期末/期中/大作业、工程实训、大创等学科竞赛比赛、初期项目立项、学习/练手等方面中 可借鉴此优质项目实现复刻，也可以基于此项目进行扩展来开发出更多...
bupt计导 期末课设，模拟双核cpu，带报告
01-24
模拟一个简易的冯诺依曼式计cpu算机CPU的工作。 该CPU字长为16位，共11个寄存器，其中3个系统寄存器，分别为程序计数器，指令寄存器，标志寄存器；8个通用寄存器，即寄存器1、2、3、4（数据寄存器），寄存器5、6、7...
cpu模拟器c语言实现_安卓逆向之模拟器检测
weixin_39769091的博客
12-27 374
最近疫情又严重了，大家注意防范哦，出门一定要带口罩，今天小编给大家带来，模拟器检测，希望对大家有所帮助，让我们一起共同进步。简单介绍模拟检测的原理模拟器检测，顾名思义，软件、手游等不能运行在模拟器上面。灰黑产：比如一个游戏能在模拟器上实现批量刷金币，或者是其他功能，但是模拟器没法启动起来，这种情况就得换真机，成本也就多了。从正向防护角度来看，如何检测模拟器？wifi、蓝牙、电量(是不是一直百分百)...
c语言源码虚拟模拟器
11-20
c语言源码虚拟模拟器
gd32f303 设计中断优先级_RTOS内核的设计与实现
weixin_39706861的博客
11-21 678
介绍基于 AVR 的 RTOS 内核的设计和实现，名为 ROS。访问我的博客获得更好的阅读体验。Logo 设计 @番茄ROS GitHub​github.com 1. 我想要怎么的RTOSROS作为一个RTOS（Real-Time Operating System）的实现，它的核心（内核）是 scheduler（调度器），负责任务的调度。而其他的系统工具比如： Semaphore、 Queue ...
北邮2021计导大作业丨C语言实现冯诺依曼式计算机CPU模拟器（一）：单核版
yufanwenshu的博客
06-11 1669
北邮2021计导大作业，单核版cpu模拟器。该代码为一种可能的实现思路，已经在OJ上提交并且全部AC，仅供大家参考、交流
你写出来的C语言是这样调用硬件的！
10-24 421
大家都知道我们可以使用C语言写一段程序来控制硬件工作，但你知道其工作原理吗？网友北极C语言在实际运行中，都是以汇编指令的方式运行的，由编译器把C语言编译成汇编指令，CPU...
北邮2021计导大作业丨C语言实现冯诺依曼式计算机CPU模拟器（二）：多核版
yufanwenshu的博客
06-18 1009
北邮2021计导大作业的第二部分，多核版cpu模拟器。
冯多依曼CPU——C语言实现
Strive_LiJiaLe的博客
10-22 464
hahah
“不懂 CPU 工作原理又如何，直接用代码模拟一个！”
CSDN资讯
06-08 3791
近日，一位来自 BBC 的软件工程师Daniel Harper 从浅入深，分享了以代码的方式来实现 CPU 所有功能的可行性，希望对大家了解计算机的内容原理有所帮助。 作者 |Daniel Harper 译者 |王艳妮，责编 | 屠敏 出品 | CSDN（ID：CSDNnews） 以下为译文： 几个月前，我突然意识到自己并不真正理解计算机内部的工作原理。我仍然不明白现代计算...
Python学习 - 冯诺伊曼体系结构建模与模拟 之TOY模型机
ZHENG
11-13 6489
mem = [0] * 1000 # 主存 reg = [0] * 10 # 通用寄存器 pReg = 0 # 程序计数器 iReg = 0 # 指令寄存器 res = 0 # 存放输出结果 # 加载TOY2程序 def loadProgram(file): global pReg, iReg, reg, mem # 全局变量声明 # *********** Beg...
冯诺依曼结构：机器级程序设计-第1关：用HT计算机编写程序
obstacle19的博客
02-28 201
假设某机器——HT——内存为1024个单元，地址范围为0000000000~1111111111（十进制00～1023），因此需10位来表示内存地址 ，每个内存单元可以存储16位信息，用来保存数据和指令。这台机器的CPU有2个专用寄存器：程序计数器和指令寄存器，程序计数器用来保存当前执行的代码的地址，指令寄存器用来保存从内存读入的当前要执行的指令
Bupt_United嵌入式C语言编程规范与指南
首先，文档的范围界定为Bupt_United嵌入式开发小组内部使用的C语言代码规范，旨在提高新开发的代码质量和一致性，同时也鼓励对现有开源代码进行适当的优化以符合这些规范。 文档简介中提到了三个核心目标：代码的...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值