操作系统实验报告【太原理工大学】

阳光穿透心脏的1/2处 2023-09-29 14:08 45阅读 0赞

## 操作系统实验报告 ##

`温馨提示：仅供参考！`

--------------------

#### 目录 ####

*  操作系统实验报告
 *   *  一、进程调度程序设计
     *   *  1.程序清单
         *  2.运行结果
         *  3.分析总结
     *  二、页式虚拟存储管理程序设计
     *   *  1.程序清单
         *  2.运行结果
         *  3.分析总结
     *  三、几种操作系统界面的熟悉
     *   *  1.程序清单
         *  2.运行结果
         *  3.分析总结

### 一、进程调度程序设计 ###

#### 1.程序清单 ####

#include<stdio.h>
    #include<stdlib.h>
    #define furthest 5
    struct process       /*PCB STRUCTURE*/
    {
         
    	int id;
    	int priority;
    	int cputime;
    	int alltime;
    	char state;
    	int next; 
    }prochain[furthest+1]; //队列中有5项实际的内容，而数组0号内放着head，next指向下一个数组的0号 
    	int procnum;
    	int rand();
    	int algo;
    	int run,head,tail,j;
    void init();//声明函数 
    void prisch();//声明函数
    void print(); //声明函数
    void timesch();//声明函数
    void insert(int q);//声明函数
    void insert2(); //17-22行对函数进行了声明，如果使用自己定义的函数，这个函数在调用它的函数的后面（main函数后面），
    				//必须在调用之前进行函数声明。因为程序是从上到下逐行编译的，若无函数声明，则会无法识别函数。
    				//则函数头必须写在main函数的前面如果使用自己定义的函数，这个函数在调用它的函数的后面（main函数后面）。
    int main(){
        		 
    	agan: printf("type the algorithm is (1:RR,2:PRIO):");
    	scanf("%d",&algo);
    	if(algo==2){
         
    		printf("output of priority.\n");  //优先级 
    		init();
    		prisch();
    		}
    	else{
        
    		if(algo==1){
        
    			printf("output of round robin.\n");  //轮转法 
    			init();
    			timesch();}
    		else{
        
    			printf("try again,please\n");
    			goto agan;
    			}
    		}
    	for(j=1;j<=40;j++)    
    		{
          printf("="); }
    	printf("\n\n");
    	for(j=1;j<=40;j++)
    		{
         printf("="); }
    	printf("\n\n");
    	printf("system finished\n"); 
    }
    void print(){
                            
        int k,p;
    	for(k=1;k<=40;k++)
    		printf("=");
    	printf("\nrunning proc.                ");
    	printf("waiting queue.");
    	printf("\n    %d      ",prochain[run].id);
    	p=head;
    	while(p!=0){
         
    		printf("%5d",p);
    		p=prochain[p].next;}
    		printf("\n");
    	for(k=1;k<=40;k++)
    		printf("=");
    	printf("\n");
    	printf(" id            ");
    	for(k=1;k<furthest+1;k++)
    		printf("%5d",prochain[k].id);
    	printf("\n");
    	printf("priority       ");
    	for(k=1;k<furthest+1;k++)
    		printf("%5d",prochain[k].priority);
    	printf("\n");
    	printf("cputime        ");
    	for(k=1;k<furthest+1;k++)
    		printf("%5d",prochain[k].cputime);
    	printf("\n");
    	printf("alltime        ");
    	for(k=1;k<furthest+1;k++)
    		printf("%5d",prochain[k].alltime);
    	printf("\n");
    	printf("state          ");
    	for(k=1;k<furthest+1;k++)
    		printf("%5c",prochain[k].state);
    	printf("\n");
    	printf("next           ");
    	for(k=1;k<furthest+1;k++)
    		printf("%5d",prochain[k].next);
    	printf("\n");
    }
    
    void insert(int q)      /*INSERT A PROCESS*/
    {
               
    	int p,s;
    	p=head;
    	s=prochain[head].next;
    	while((prochain[q].priority<prochain[s].priority)&&(s!=0)){
         
    		p=s;
    		s=prochain[s].next;
    		}
    		prochain[p].next=q;
    		prochain[q].next=s;
    } 
    void insert2()    /*PUT A PROCESS ONTO THE TAIL OF THE QUEUE*/
    {
               
    		prochain[tail].next=run;
    		tail=run;
    		prochain[run].next=0;
    	}
    
    void init()     /*CREATE A WAITING QUEUE*/
    	{
               
    		int i;
    		head=0;
    		if(algo==2){
         
    			for (i=1;i<furthest+1;i++){
         
    				prochain[i].id=i;                      //进程标识符id 
    				prochain[i].priority=(rand()+11)%41;   //优先数/轮转时间片数 
    				prochain[i].cputime=0;                 //占用CPU时间片数
    				prochain[i].alltime=(rand()+1)%7;      //进程所需时间片数
    				prochain[i].state='W';                 //进程状态 
    				prochain[i].next=0;                    //链指针 
    				if((prochain[i].priority<prochain[head].priority)&&(head!=0))
    					insert(prochain[i].id);
    				else{
        
    					prochain[i].next=head;
    					head=prochain[i].id;
    					}
    			}     
    		}
    		else{
        
    			for (i=1;i<furthest+1;i++){
         
    				prochain[i].id=i;
    				prochain[i].priority=(rand()+1)%3+1;
    				prochain[i].cputime=0;
    				prochain[i].alltime=(rand()+1)%7;
    				prochain[i].state='W';
    				prochain[i].next=(i+1)%(furthest+1);}
    				head=1;
    				tail=furthest; 
    				prochain[furthest].next=0;
    				}
    			run=head;
    			prochain[run].state='R';
    			head=prochain[head].next;
    			prochain[run].next=0;
    			print();
    		}
    //prisch为优先级 
    void prisch()      /*THE PROCESS WITH PRIO ALGORITHM*/
    	{
               
    		while(run!=0){
        
    		if(prochain[run].alltime==0){
        
    				prochain[run].state='F';
    				prochain[run].next=0;
    				if(head!=0){
        
    					run=head;
    					prochain[run].state='R';
    					head=prochain[head].next;}
    				else{
         
    					prochain[0].id=prochain[run].id;
    					run=0;
    					}
    			}                 //运行中要先用if语句判断一下第一个运行的alltime是否为0,若为0, 
    							 //则直接从RUN状态变为FINISH状态，接着才能运行下面的内容,否则
    							 //alltime为负值则会一直无限循环下去 
    			prochain[run].cputime+=1;
    			prochain[run].priority-=3;
    			prochain[run].alltime-=1;
    
    			/*下面的运行后也要再用if语句判断一下运行后的alltime是否为0,
    			若为0, 则直接从RUN状态变为FINISH状态，接着才能运行下面的内
    			容,否则alltime为负值也会一直无限循环下去 */ 
    			if(prochain[run].alltime==0){
        
    				prochain[run].state='F';
    				prochain[run].next=0;
    				if(head!=0){
        
    					run=head;
    					prochain[run].state='R';
    					head=prochain[head].next;}
    				else{
         
    					prochain[0].id=prochain[run].id;
    					run=0;
    					}
    			}
    			else{
          
    				if((prochain[run].priority<prochain[head].priority)&&(head!=0)){
         
    					prochain[run].state='W';
    					insert(run);
    					run=head;
    					prochain[run].state='R';
    					head= prochain[head].next;
    				}
    			}
    		print();
    		}
     	}
    /*
    	下面轮转法中timesch函数下的重要性就相当于用priority表示，使用priority次数用尽
    	后，继续执行下一个进程，在进程都结束后，占用cpu时间开始累加直至结束。 
    */ 
    void timesch()      /*THE PROCESS WITH RR ALRORITHM*/
    	{
        	  
    		while(run!=0){
         
    			
    			if(prochain[run].alltime==0){
         
    				prochain[run].state='F';
    				prochain[run].next=0;
    				if(head!=0){
         
    					run=head;
    					prochain[run].state='R';
    					head=prochain[head].next;
    					}
    				else{
         
    					prochain[0].id=prochain[run].id;
    					run=0;
    					}
    			}
    			//上述if语句同优先级方法类似，先判断alltime是否为0，可以解决死循环问题 
    			
    			prochain[run].alltime-=1;
    			prochain[run].cputime+=1;
    			if(prochain[run].alltime==0){
         
    				prochain[run].state='F';
    				prochain[run].next=0;
    				if(head!=0){
         
    					run=head;
    					prochain[run].state='R';
    					head=prochain[head].next;
    					}
    				else{
         
    					prochain[0].id=prochain[run].id;
    					run=0;
    					}
    			}
    			else{
         
    				if((prochain[run].cputime==prochain[run].priority)&&(head!=0)){
         
    					prochain[run].state='W';
    					prochain[run].cputime=0;
    					insert2();
    					run=head;
    					prochain[run].state='R';
    					head=prochain[head].next;
    					}
    				}
    		print();
    		}
    }

#### 2.运行结果 ####

① 简单轮转法：  
![在这里插入图片描述][6b15d798f17a4e85bbd570a893e2d541.png_pic_center]

![在这里插入图片描述][794b7a590f09401fb8dcb15e0edc1e25.png_pic_center]

![在这里插入图片描述][a3b02cccb7b24f389426dd5c0ac01f16.png_pic_center]  
  
  
② 优先数法

![在这里插入图片描述][7a42a086fd994467b5aa04a343737f7a.png_pic_center]

#### 3.分析总结 ####

> 此实验运用了俩种方法进行了程序的调度。在简单轮转方法中，本程序代码中timesch函数下的重要性用priority表示，使用priority次数用尽后，继续执行下一个进程，在进程都结束后，占用cpu时间才开始累加直至结束。  
> 而在优先数方法中，每一次都要判断一下优先级最高的进程，然后alltime进行减1，cputime加1处理，直到alltime为0后，进程状态才由“R”变为“F”。  
> 在本实验纠错过程中，两种方法下程序在第一次不判断alltime是否为0时就会出现所谓的“死”循环，在时间片减1、优先数减3或者时间片减1、cpu时间加1后，还要再次进行alltime是否为0的判断，两者都要存在才能保证程序的正常运行。

### 二、页式虚拟存储管理程序设计 ###

#### 1.程序清单 ####

#include<stdio.h>
    #define number 7
    #define null -1
    struct page_table
    {
        
    	int page_number;   
    	int sign;  
    	int block;  
    	int modify;  
    	int place;  
    };
    struct page_table work_page[number]={
        {
        0,1,5,0,11},{
        1,1,8,0,12},{
        2,1,9,0,13},
    				{
        3,1,1,0,21},{
        4,0,null,0,22},{
        5,0,null,0,23},{
        6,0,null,0,121}};
    struct performance_list
    {
        
    	int list_number;
    	char operation[8];
    	int page_number;
    	int page_address;
    };
    struct performance_list work_list[12]={
        {
        1,"+",0,70},{
        2,"+",1,50},
    			{
        3,"*",2,15},{
        4,"存",3,21},{
        5,"取",0,56},{
        6,"-",6,40},{
        7,"移位",4,53},
    			{
        8,"+",5,23},{
        9,"存",1,37},{
        10,"取",2,78},{
        11,"+",4,1},{
        12,"存",6,84}};
    int main(){
        	
    	int new_number,new_sign,new_block,new_modify,new_list_number,j;
    	char new_place[6],new_operation[8]; 
    	int p[4]={
        0,1,2,3};//四块主存块 
    	int k=0;
    	int m=4;
    	long new_address;
    	printf("\n   序号\t  操作\t  页号\t  页内地址\t 标志位\t  绝对地址\t  页号变化\t 块号\t绝对地址\n");
    	for(int i=0;i<12;i++)
    	{
        
    		new_list_number=work_list[i].list_number;
    		printf("%5d",new_list_number);  //输出序号 
    		new_number=work_list[i].page_number;
    		new_sign=work_page[new_number].sign;
    		new_block=work_page[i].block;
    		new_modify=work_page[i].modify;
    		if(new_sign==1)
    			new_address=work_page[new_number].block*1024+work_list[i].page_address;
    		else{
        			
    			j=p[k];
    			p[k]=new_number;
    			k=(k+1)%m;
    			work_page[new_number].sign=1;   //修改标志位改为1
    			work_page[new_number].block=work_page[j].block;
    			work_page[j].block=-1;
    			work_page[j].sign=0;
    			work_page[j].modify=0;
    			new_address=work_page[new_number].block*1024+work_list[i].page_address;
    		}
    		if(work_list[i].operation=="存")
    			work_page[new_number].modify=1;
    		printf("	%5s",work_list[i].operation);//输出操作 
    		printf("      %d",new_number);//输出页号 
    		printf("	    %2d",work_list[i].page_address);//输出页内地址 
    		printf("             %d",new_sign);//输出标志位 
    		if(new_sign==1)
    			printf("       %d",new_address);// 输出绝对地址 
    		else
    			printf("        *%d",work_list[i].page_number);//输出*页号 
    		if(new_sign==1)
    			printf("                       \t");//无地址转换输出空格 
    		else
    			printf("              %d->%d\t",work_list[i].page_number,j);//展示地址的变化 
    		printf("  %d",work_page[new_number].block);//输出相应的块号 
    		printf("       %d",new_address);
    		printf("\n");
    	}
    }

#### 2.运行结果 ####

![在这里插入图片描述][66e931240ca94a9c87821d5fc4c7be17.png_pic_center]

#### 3.分析总结 ####

> 首先将作业的页表与作业的指令序列链接起来，形成一个新表，然后根据新表通过判断是否为标志位以及是否为“存”指令进行绝对地址的计算。在页表中通过增加是否修改过的标志，（当执行“存”指令、“写”指令时把对应页的修改标志置成“1”，表示该页修改过，否则为“0”，表示该页未修改过），来对“存”指令以及页面是否调出进行了判断。实验中标志位为“0”时，进行了页号的修改，修改后进行绝对地址的计算。

### 三、几种操作系统界面的熟悉 ###

#### 1.程序清单 ####

① C语言编写9\*9乘法表

![在这里插入图片描述][577228520db04650beab56c351dc16e0.png_pic_center]  
  
  
② python 编写9\*9乘法表

![在这里插入图片描述][d57d09c47b314d5695e39a20e37a0477.png_pic_center]

#### 2.运行结果 ####

![在这里插入图片描述][8a1020217f8f4f47924c3d28c913ca62.png_pic_center]  
  
  
![在这里插入图片描述][92f0078f64a2490aadac2223ddb4d605.png_pic_center]

#### 3.分析总结 ####

> 熟悉多种操作系统的界面，在熟练使用机器的基础上，了解了各种操作命令和系统调用在系统中的大致工作过程。熟悉系统实用程序的调用方法和各种系统调用模块的功能和作用，从而有效地使用计算机。

[6b15d798f17a4e85bbd570a893e2d541.png_pic_center]: https://img-blog.csdnimg.cn/6b15d798f17a4e85bbd570a893e2d541.png#pic_center
[794b7a590f09401fb8dcb15e0edc1e25.png_pic_center]: https://img-blog.csdnimg.cn/794b7a590f09401fb8dcb15e0edc1e25.png#pic_center
[a3b02cccb7b24f389426dd5c0ac01f16.png_pic_center]: https://img-blog.csdnimg.cn/a3b02cccb7b24f389426dd5c0ac01f16.png#pic_center
[7a42a086fd994467b5aa04a343737f7a.png_pic_center]: https://img-blog.csdnimg.cn/7a42a086fd994467b5aa04a343737f7a.png#pic_center
[66e931240ca94a9c87821d5fc4c7be17.png_pic_center]: https://img-blog.csdnimg.cn/66e931240ca94a9c87821d5fc4c7be17.png#pic_center
[577228520db04650beab56c351dc16e0.png_pic_center]: https://img-blog.csdnimg.cn/577228520db04650beab56c351dc16e0.png#pic_center
[d57d09c47b314d5695e39a20e37a0477.png_pic_center]: https://img-blog.csdnimg.cn/d57d09c47b314d5695e39a20e37a0477.png#pic_center
[8a1020217f8f4f47924c3d28c913ca62.png_pic_center]: https://img-blog.csdnimg.cn/8a1020217f8f4f47924c3d28c913ca62.png#pic_center
[92f0078f64a2490aadac2223ddb4d605.png_pic_center]: https://img-blog.csdnimg.cn/92f0078f64a2490aadac2223ddb4d605.png#pic_center