计算机体系结构实验报告.docx
《计算机体系结构实验报告.docx》由会员分享,可在线阅读,更多相关《计算机体系结构实验报告.docx(14页珍藏版)》请在冰豆网上搜索。
计算机体系结构实验报告
中南大学
计算机体系结构
实验报告
学生姓名
学院信息科学与工程学院
专业班级
完成时间2015年10月27日
计算机体系结构
1.实验内容
实验1对指令操作码进行霍夫曼编码
实验2使用LRU方法更新Cache
2.实验1:
对指令操作码进行霍夫曼编码
2.1实验目的
了解和掌握指令编码的基本要求和基本原理
2.2实验内容
使用编程工具编写一个程序,对一组指令进行霍夫曼编码,并输出最后的编码结果以及对指令码的长度进行评价。
与扩展操作码和等长编码进行比较。
要对指令的操作码进行HUFFMAN编码,只要根据指令的各类操作码的出现概率构造HUFFMAN树再进行HUFFAM编码。
此过程的难点构造HUFFMAN树,进行HUFFAM编码只要对你所生成的HUFFMAN树进行中序遍历即可完成编码工作。
2.3实验结果
3.实验2:
使用LRU方法更新Cache
3.1实验目的
了解和掌握寄存器分配和内存分配的有关技术。
3.2实验内容
Cache更新:
结合数据结构的相关知识,使用LRU的策略,对一组访问序列进行内部的LRU置换算法是选择最近最久未使用的页面予以置换。
该算法赋予每个页面一个访问字段,用来记录一个页面自上次被访问以来经历的时间T,当须淘汰一个页面时,选择现有页面中T值最大的,即最近最久没有访问的页面。
这是一个比较合理的置换算法。
3.3实验结果
4.总结
实验一是曾在学习数字通信原理课程时编写的,当时只有简单的排序后编码的功能,学习了数据结构后,我往里面加入了树的结构,使编码后的结果更加清晰明了了。
学习了计算机体系结构之后,我又往里面加入了求编码长度的功能。
通过这个程序,我更加了解哈夫曼编码的知识了。
实验二是写出LRU算法,这个相对来说比较简单,因为在学习操作系统原理时接触过FIFO等等算法并且编程实现了,难点在于输出结果的排版,一开始我想输出一个表格,这样更符合书上关于此算法的内容,但是出现了各种不对齐的问题,最后只好让它直接输出结果。
通过这几次实验,我发现了自身的不足,比如没有很好的书写习惯,考虑问题不周到,对于计算机体系结构课程中知识的理解不够深入等。
但在编程的过程中我体验到了一分耕耘一分收获的喜悦;多次调试后程序成功运行了,那时候的欢乐是我以前无法想象的。
果然,学习任何一门课程,只要学得用心,都可以从中体会到学习的快乐。
今后我的进步,想必都是从这一点一点敲入编译器的代码中获得的。
5.代码附录
实验1
#include
#include
usingnamespacestd;
#defineN8
classhuff_p{
public:
huff_p*r_child;//大概率的节点;
huff_p*l_child;//小概率的节点;
charop_mask[3];//指令标号;
floatp;//指令使用概率;};
classf_min_p{
public:
f_min_p*next;
charop_mask[3];//指令标号;
floatp;//指令使用概率;
huff_p*huf_p;};
classhuff_code{
public:
huff_code*next;
floatp;
charop_mask[3];
charcode[N];//huffman编码;};
f_min_p*input_instruct_set();//输入指令集子模块;
huff_p*creat_huffman_tree(f_min_p*head);//构造huffman树;
f_min_p*fin_min(f_min_p*h);
f_min_p*del_min(f_min_p*h,f_min_p*p);
voidinsert_n(f_min_p*h,f_min_p*p);
huff_p*creat_huffp(f_min_p*p);
voidcreat_huffman_code(huff_p*h1,huff_code*h);//生成huffman编码;
voidr_find(huff_p*p1,charcode[],inti,huff_code*h);
voidoutput_huffman(huff_code*head);//输出huffman编码;
voidcal_sort_length(huff_code*head);//计算指令用huffman编码的平均编码字长
intmain(){
f_min_p*h,*h1;
huff_p*root;
huff_code*head,*pl;
inti=0;
h=input_instruct_set();
h1=h;
root=creat_huffman_tree(h1);
head=newhuff_code;
head->next=NULL;
creat_huffman_code(root,head);
output_huffman(head);
cal_sort_length(head);
pl=head->next;
while(pl){
deletehead;
head=pl;
pl=pl->next;}}
f_min_p*input_instruct_set(){
f_min_p*head;
f_min_p*h;
h=newf_min_p;
h->next=NULL;
h->huf_p=NULL;
head=h;
intn;
cout<<"请输入指令数:
";
cin>>n;
cout<<"请输入指令标号:
";
cin>>h->op_mask;
cout<<"请输入指令的使用概率:
";
cin>>h->p;
inti=0;
f_min_p*point;
f_min_p*p1=head;
for(;ipoint=newf_min_p;
cout<<"请输入指令标号:
";
cin>>point->op_mask;
point->op_mask[2]='\0';
cout<<"请输入指令的使用概率:
";
cin>>point->p;
point->huf_p=NULL;
point->next=p1->next;
p1->next=point;
p1=point;}
returnhead;}
huff_p*creat_huffman_tree(f_min_p*h){
f_min_p*h1,*min1,*min2,*comb;
huff_p*head,*rd,*ld,*parent;
h1=h;
min1=fin_min(h1);
ld=creat_huffp(min1);
h1=del_min(h1,min1);
if(h1->next)
min2=fin_min(h1);
else
min2=h1;
rd=creat_huffp(min2);
comb=newf_min_p;
comb->next=NULL;
comb->p=rd->p+ld->p;
comb->op_mask[0]='\0';
comb->op_mask[1]='\0';
parnt=creat_huffp(comb);
insert_n(h1,comb);
if(h1->next!
=NULL)
h1=del_min(h1,min2);
parent->l_child=ld;
parent->r_child=rd;
comb->huf_p=parent;
head=parent;
inti=0;
while(h1->next!
=NULL){
min1=fin_min(h1);
if(min1->huf_p==NULL){
ld=creat_huffp(min1);}
else{
ld=min1->huf_p;}
h1=del_min(h1,min1);
if(h1->next)
min2=fin_min(h1);
else
min2=h1;
if(min2->huf_p==NULL){
rd=creat_huffp(min2);}
else{
rd=min2->huf_p;}
comb=newf_min_p;
comb->next=NULL;
comb->p=rd->p+ld->p;
comb->op_mask[0]='\0';
comb->op_mask[1]='\0';
parent=creat_huffp(comb);
if(h1!
=NULL)
insert_n(h1,comb);
if(h1->next!
=NULL)
h1=del_min(h1,min2);
parent->l_child=ld;
parent->r_child=rd;
comb->huf_p=parent;
head=parent;
if(h1->next==NULL)break;}
deletecomb;
returnhead;}
f_min_p*fin_min(f_min_p*h){
f_min_p*h1,*p1;
h1=h;
p1=h1;
floatmin=h1->p;
h1=h1->next;
while(h1){
if(min>(h1->p)){
min=h1->p;
p1=h1;}
h1=h1->next;}
returnp1;}
f_min_p*del_min(f_min_p*h,f_min_p*p){
f_min_p*p1,*p2;
p1=h;
p2=h;
if(h==p){
h=h->next;
deletep;}
else{
while(p1->next!
=NULL){
p1=p1->next;
if(p1==p){
p2->next=p1->next;
deletep;
break;}
p2=p1;}}
returnh;}
voidinsert_n(f_min_p*h,f_min_p*p1){
p1->next=h->next;
h->next=p1;}
huff_p*creat_huffp(f_min_p*d){
huff_p*p1;
p1=newhuff_p;
p1->l_child=NULL;
p1->r_child=NULL;
p1->p=d->p;
p1->op_mask[0]=d->op_mask[0];
p1->op_mask[1]=d->op_mask[1];
returnp1;}
voidr_find(huff_p*p1,charcode[],inti,huff_code*h){
if(p1->l_child){
code[i]='1';
r_find(p1->l_child,code,i+1,h);}
if(p1->op_mask[0]!
='\0'){
huff_code*p2=newhuff_code;
p2->op_mask[0]=p1->op_mask[0];
p2->op_mask[1]=p1->op_mask[1];
p1->op_mask[2]='\0';
p2->p=p1->p;
intj;
for(j=0;j
p2->code[j]=code[j];}
p2->code[j]='\0';
p2->next=h->next;
h->next=p2;}
if(p1->r_child){
code[i]='0';
r_find(p1->r_child,code,i+1,h);}
deletep1;}
voidcreat_huffman_code(huff_p*h1,huff_code*h){
inti=0;
charcode[N];
r_find(h1,code,i,h);}
voidoutput_huffman(huff_code*head){
huff_code*h=head->next;
cout<cout<<"标号:
"<<"--概率--"<<''<<"--编码--"<cout<<"---------------------------------"<while(h){
h->op_mask[2]='\0';
cout<op_mask<<":
"<p<<""<code<h=h->next;}
cout<<"---------------------------------"<cout<voidcal_sort_length(huff_code*head){
huff_code*h=head->next;
doublej=0;
floatone_length=0;
floatper_length=0;
floatext_length=0;//按1-2-3-5扩展编码的最小长度为。
while(h){
floatlength=0;
inti=0;
while(h->code[i]!
='\0'){
length++;
i++;}
one_length=h->p*length;
per_length=per_length+one_length;//12
h=h->next;
j++;}
inti1=int(j);
huff_code*p2=head->next;
float*p_a=newfloat[i1];
inti0=0;
while(p2){
p_a[i0++]=p2->p;
p2=p2->next;}
floatmax,temp;
intl;
for(ints=0;smax=p_a[s];
l=s;
for(intk=s+1;kif(maxmax=p_a[k];l=k;}}
temp=p_a[s];
p_a[s]=max;
p_a[l]=temp;}
float*code_len=newfloat[i1];
code_len[0]=1;
code_len[1]=2;
code_len[2]=3;
code_len[3]=5;
for(inti=4;iwhile(lext_length=ext_length+code_len[l]*p_a[l];}
doubleq_length=log10(j)/log10
(2);
cout<<"此指令集操作码huffman编码的平均长度为"<cout<<"等长编码的平均长度为"<cout<<"按1-2-3-5的扩展编码的最短平均编码长度为"<cout<cout<实验2
#include
#include
#defineM4
#defineN12
#defineMyprintfprintf("|---+---+---+---+---+---+---+---+---+---+---+---|\n")
typedefstructpage
{intnum;/*记录页面号*/
inttime;/*记录调入内存时间*/
}Page;/*页面逻辑结构,结构为方便算法实现设计*/
Pageb[M];/*内存单元数*/
intc[M][N];/*暂保存内存当前的状态:
缓冲区*/
intqueue[100];/*记录调入队列*/
intK;/*调入队列计数变量*/
voidInit(Page*b,intc[M][N])
{inti,j;
for(i=0;ib[i].num=-1;
b[i].time=N-i-1;}
for(i=0;ifor(j=0;jc[i][j]=-1;}
intGetMax(Page*b)
{inti;
intmax=-1;
inttag=0;
for(i=0;i{if(b[i].time>max){
max=b[i].time;
tag=i;}}
returntag;}
intEquation(intfold,Page*b){inti;
for(i=0;i{if(fold==b[i].num)
returni;}
return-1;}
voidLru(intfold,Page*b)
{inti;
intval;
val=Equation(fold,b);
if(val>=0)
{b[val].time=0;
for(i=0;iif(i!
=val)
b[i].time++;}
else
{queue[++K]=fold;/*记录调入页面*/
val=GetMax(b);
b[val].num=fold;
b[val].time=0;
for(i=0;iif(i!
=val)
b[i].time++;}}
intmain(){
inta[N]={1,1,2,4,3,5,2,1,6,7,1,3};
inti,j;
start:
K=-1;
Init(b,c);
for(i=0;iLru(a[i],b);
c[0][i]=a[i];
for(j=0;jc[j][i]=b[j].num;}
printf("内存状态为:
\n");
for(j=0;jprintf("%2d",a[j]);
printf("\n");
for(i=0;i{for(j=0;jif(c[i][j]==-1)printf("%2c",32);
elseprintf("%2d",c[i][j]);}
printf("\n");}
printf("\n调入队列为:
");
for(i=0;iprintf("%3d",queue[i]);
printf("\n缺页次数为:
%6d\n缺页率:
%16.6f\n",K+1,(float)(K+1)/N);}