操作系统实验指导_源码参考资料
操作系统实验源代码
#include "iostream.h"typedefstructpcb{char name[10]; //进程名char state; //状态w(就绪)r(运行)f(结束)int id; //id号int super; //优先级intntime; //需运行的时间intrtime; //已运行的时间structpcb *next;}*pcb1;pcb1s,w;voidinit(pcb1 &r){r=NULL;}void print(){pcb1 p;cout<<"您现在查看的是就绪队列的信息:" <<endl;cout<<"进程号"<<"进程名"<<"优先级"<<"状态"<<"已运行时间"<<"需运行时间"<<endl;for(p=s;p!=NULL;p=p->next){cout<<p->id<<" "<<p->name<<" "<<p->super<<" "<<p->state<<" "<<p->rtime<<" "<<p->ntime<<endl; }}void print1(){pcb1 p;cout<<"您现在查看的是阻塞队列的信息";cout<<"进程号"<<"进程名"<<"优先级"<<"状态（w,r,f）"<<"已运行时间"<<"需运行时间"<<endl;for(p=w;p!=NULL;p=p->next){cout<<p->id<<" "<<p->name<<" "<<p->super<<" "<<p->state<<" "<<p->rtime<<" "<<p->ntime<<endl; }}int empty(pcb1 &r){if(r==NULL)return 0;elsereturn 1;}int check(){pcb1 p;p=s;if(p->rtime==p->ntime){p->state='F';cout<<"进程"<<p->id<<" 已经结束"<<endl;return 0;}elsereturn 1;}void sort(pcb1 &r,pcb1 p) {pcb1 p1,p2;int in=0;if(r==NULL){r=p;}else{if(p->super>=r->super) {p->next=r;r=p;}else{p1=r;p2=r->next;if(p2==NULL){r->next=p;}else{while(in==0&&p2!=NULL) {if(p->super>=p2->super) {p->next=p2;p1->next=p;in=1;}else{p1=p1->next;p2=p2->next;}}}if(in==0)p1->next=p;}}void block(){if(empty(s)){if(s->next==NULL){sort(w,s);s=s->next;}else{pcb1 p1;p1=s;s=s->next;p1->next=NULL;sort(w,p1);}}else{cout<<"现在就绪队列已经为空，再没有进程需要阻塞!"<<endl; } }void wake(){if(empty(w)){pcb1 p1;p1=w;w=w->next;p1->next=NULL;sort(s,p1);}else{cout<<"阻塞队列已经为空，没有进程再需要唤醒!"<<endl; }}voidruning(){if(empty(s)){pcb1 p;p=s;if(check()){s=s->next;p->rtime++;p->super--;p->next=NULL;sort(s,p);}else{s=s->next;}}else{cout<<"就绪队列已经为空!"<<endl; }}void input(){pcb1 p2;p2=new pcb;cout<<"请输入进程号、进程名、进程优先级、需要运行时间"<<endl; cin>>p2->id>>p2->name>>p2->super>>p2->ntime;p2->rtime=0;p2->state='W';p2->rtime=0;p2->next=NULL;sort(s,p2);}void main(){charch;init(s);init(w);cout<<"**************进程调度模拟程序开始**************"<<endl; cout<<"*** w->唤醒进程***"<<endl; cout<<"*** r->运行进程***"<<endl; cout<<"*** z->阻塞进程***"<<endl; cout<<"*** q->退出程序***"<<endl; cout<<"*** c->创建进程***"<<endl; cout<<"*** s->查看就绪进程***"<<endl;cout<<"*** l->查看阻塞队列***"<<endl; cout<<"************************************************"<<endl; while(ch!='q'){cout<<"请选择功能（w,r,z,q,c,s,l）:"<<endl;cin>>ch;switch(ch){case 'c':input(); break;case 'r':runing(); break;case 's':print(); break;case 'w':wake(); break;case 'l':print1(); break;case 'z':block(); break;}}}。
操作系统实验2源代码
操作系统实验报告二【源代码】一、在VisualC++6.0中实现。
【程序代码】#include<iostream.h>#include<iomanip.h>#define Number 5void main(){int daoda[Number],fuwu[Number],i;for(i=0;i<Number;i++){cout<<"请输入第"<<i+1<<"个进程的到达时间和服务时间，并以空格间隔:";cin>>daoda[i]>>fuwu[i];}struct statedd //声明结构{bool doneF,doneS;int daoda,fuwu;float wancheng,zhouzhuan,daiquan,wan,zhou,dai;};statedd process[Number];//声明结构变量，这里为数组int timeflyF=0,timeflyS=0;//定义两个类似于秒表的变量int j,k,nextproF,nextproS;// 获取数据for(i=0;i<Number;i++){process[i].doneF = false;process[i].doneS = false;process[i].wancheng = 0;process[i].zhouzhuan = 0;process[i].daiquan = 0;process[i].wan = 0;process[i].zhou = 0;process[i].dai =0;process[i].daoda = daoda[i];process[i].fuwu = fuwu[i];}// 获取最先到达的进程下标firstint first=0;for(i=1;i<Number;i++){if(daoda[first]>daoda[i])first=i;}process[first].doneF=true;process[first].doneS=true;process[first].wancheng = process[first].fuwu + process[first].daoda;process[first].wan = process[first].fuwu + process[first].daoda;timeflyF += process[first].daoda+process[first].fuwu;timeflyS += process[first].daoda+process[first].fuwu;// 接下去到达的进程//******************************************************************** // fcfs ********************************************************for(j=1;j<Number;j++){nextproF = Number+1;for(k =0 ; k<Number; k++ ){if( !process[k].doneF ){if( process[k].daoda <= timeflyF ) // 到达{if( nextproF ==Number+1)nextproF = k;else{if( process[nextproF].daoda > process[k].daoda )nextproF = k; //获取到达时刻最先的进程}//else}//if2}//if1}//for// 处理process[nextproF].wancheng = process[nextproF].fuwu + timeflyF;timeflyF += process[nextproF].fuwu;process[nextproF].doneF=true;} // circle2// SJF **********************************************for(j=1;j<Number;j++){nextproS = Number+1;for(k=0 ; k<Number; k++ ){if(!process[k].doneS){if( process[k].daoda <= timeflyS ) // 到达{if( nextproS ==Number+1 )nextproS = k;else{if( process[nextproS].fuwu > process[k].fuwu )nextproS = k; //获取服务时间最小的进程}//else}//if2}//if1}//for// 处理process[nextproS].wan = process[nextproS].fuwu + timeflyS;timeflyS += process[nextproS].fuwu;process[nextproS].doneS=true;} // circle2//***************************************************************************** *float Fz=0,Fdq=0,Sz=0,Sdq=0;//for(i=0;i<Number;i++){ //----------------------------------------------------process[i].zhouzhuan=process[i].wancheng-process[i].daoda;Fz += process[i].zhouzhuan;process[i].daiquan=process[i].zhouzhuan/process[i].fuwu;Fdq += process[i].daiquan;//----------------------------------------------------process[i].zhou=process[i].wan-process[i].daoda;Sz += process[i].zhou;process[i].dai=process[i].zhou/process[i].fuwu;Sdq += process[i].dai;}//=========================输出==================================//-------------------------------------------------------------------cout<<"\t"<<endl;cout<<"FCFS:"<<endl;cout<<setw(10)<<"进程ID"<<" ";cout<<setw(10)<<"完成时间"<<" ";cout<<setw(10)<<"周转时间"<<" ";cout<<setw(10)<<"带权周转时间"<<" "<<endl;for(i=0;i<Number;i++){cout<<setw(10)<<i+1<<" ";cout<<setw(10)<<setiosflags(ios::fixed)<<setprecision(2)<<process[i].wancheng<<" ";cout<<setw(10)<<setiosflags(ios::fixed)<<setprecision(2)<<process[i].zhouzhuan<<" ";cout<<setw(10)<<setiosflags(ios::fixed)<<setprecision(2)<<process[i].daiquan<<""<<endl;}cout<<"平均周转时间为："<<setiosflags(ios::fixed)<<setprecision(2)<<Fz/Number<<endl; cout<<"平均带权周转时间为："<<setiosflags(ios::fixed)<<setprecision(2)<<Fdq/Number<<endl; //-------------------------------------------------------------------cout<<"\t"<<endl;cout<<"SJF:"<<endl;cout<<setw(10)<<"进程ID"<<" ";cout<<setw(10)<<"完成时间"<<" ";cout<<setw(10)<<"周转时间"<<" ";cout<<setw(10)<<"带权周转时间"<<" "<<endl;for(i=0;i<Number;i++){cout<<setw(10)<<i+1<<" ";cout<<setw(10)<<setiosflags(ios::fixed)<<setprecision(2)<<process[i].wan<<" ";cout<<setw(10)<<setiosflags(ios::fixed)<<setprecision(2)<<process[i].zhou<<"";cout<<setw(10)<<setiosflags(ios::fixed)<<setprecision(2)<<process[i].dai<<" "<<endl; }cout<<"平均周转时间为："<<setiosflags(ios::fixed)<<setprecision(2)<<Sz/Number<<endl; cout<<"平均带权周转时间为："<<setiosflags(ios::fixed)<<setprecision(2)<<Sdq/Number<<endl; cout<<"\t"<<endl;}【效果截图】。
操作系统实验指导书
操作系统实验指导书实验概述本次操作系统实验是为了让学生通过实践了解操作系统的基本概念，原理和使用。
通过完成实验，学生将了解操作系统内核，进程调度，文件系统和输入输出等关键组成部分。
实验环境实验要求使用 Linux 操作系统，可以选择任意一种 Linux 发行版。
可以在物理机上安装 Linux，也可以使用虚拟机软件（如 VirtualBox）来运行 Linux 虚拟机。
实验准备在进行实验之前，需要完成以下准备工作：1.安装 Linux 操作系统（如 Ubuntu、Fedora 等）或虚拟机软件（如VirtualBox）。
2.熟悉 Linux 基本命令和操作，包括文件操作、进程管理等。
实验内容本次操作系统实验分为以下几个部分：1. 实验一：进程管理本部分实验要求学生了解进程管理的基本概念和原理，掌握进程创建、终止和状态转换等操作。
学生需要完成以下任务：•编写一个简单的 C 程序，实现进程的创建、终止和状态转换功能。
•使用 Linux 命令行工具编译、运行和调试 C 程序。
•观察和分析进程的状态转换过程。
2. 实验二：进程调度本部分实验要求学生了解进程调度算法的原理和实现方法，掌握优先级调度、轮转调度和最短作业优先调度等算法。
学生需要完成以下任务：•编写一个简单的 C 程序，模拟进程调度算法的执行过程。
•使用 Linux 命令行工具编译、运行和调试 C 程序。
•观察和分析不同调度算法对进程执行顺序的影响。
3. 实验三：文件系统本部分实验要求学生了解文件系统的基本概念和实现原理，掌握文件的创建、读写和删除等操作。
学生需要完成以下任务：•编写一个简单的 C 程序，实现文件的创建、读写和删除功能。
•使用 Linux 命令行工具编译、运行和调试 C 程序。
•观察和分析文件系统的存储结构和操作过程。
4. 实验四：输入输出本部分实验要求学生了解操作系统的输入输出机制和设备驱动程序的原理和实现方法，掌握文件读写、设备驱动和错误处理等操作。
操作系统实验参考代码
目录实验一WINDOWS进程初识 (2)实验二进程管理 (6)实验三进程同步的经典算法 (10)实验四存储管理 (14)试验五文件系统试验 (18)实验有关（参考）代码实验一WINDOWS进程初识1、实验目的（1）学会使用VC编写基本的Win32 Consol Application（控制台应用程序)。
（2）掌握WINDOWS API的使用方法。
（3）编写测试程序，理解用户态运行和核心态运行。
2、程序清单清单1-1 一个简单的Windows控制台应用程序// hello项目# include <iostream>void main(){std::cout << “Hello, Win32 Consol Application” << std :: endl ;}清单1-2 核心态运行和用户态运行时间比计算// proclist项目# include <windows.h># include <tlhelp32.h># include <iostream.h>// 当在用户模式机内核模式下都提供所耗时间时，在内核模式下进行所耗时间的64位计算的帮助方法DWORD GetKernelModePercentage(const FILETIME& ftKernel,const FILETIME& ftUser){// 将FILETIME结构转化为64位整数ULONGLONG qwKernel=(((ULONGLONG)ftKernel.dwHighDateTime)<<32)+ftKernel.dwLowDateTime;ULONGLONG qwUser=(((ULONGLONG)ftUser.dwHighDateTime)<<32)+ftUser.dwLowDateTime;// 将消耗时间相加，然后计算消耗在内核模式下的时间百分比ULONGLONG qwTotal=qwKernel+qwUser;DWORD dwPct=(DWORD)(((ULONGLONG)100*qwKernel)/qwTotal);return(dwPct);}// 以下是将当前运行过程名和消耗在内核模式下的时间百分数都显示出来的应用程序void main(int argc,char *argv[]){if(argc<2){cout<<"请给出你要查询的程序名"<<endl;exit(0);}// 对当前系统中运行的过程拍取“快照”HANDLE hSnapshot=::CreateToolhelp32Snapshot(TH32CS_SNAPPROCESS,// 提取当前过程0);// 如果是当前过程，就将其忽略// 初始化过程入口PROCESSENTRY32 pe;::ZeroMemory(&pe,sizeof(pe));pe.dwSize=sizeof(pe);BOOL bMore=::Process32First(hSnapshot,&pe);BOOL found = FALSE;while(bMore){// 打开用于读取的过程if(!strcmp(pe.szExeFile,argv[1])){found = TRUE;HANDLE hProcess=::OpenProcess(PROCESS_QUERY_INFORMA TION,// 指明要得到信息FALSE,// 不必继承这一句柄pe.th32ProcessID);// 要打开的进程if (hProcess!=NULL){// 找出进程的时间FILETIME ftCreation,ftKernelMode,ftUserMode,ftExit;::GetProcessTimes(hProcess,// 所感兴趣的进程&ftCreation,// 进程的启动时间&ftExit,// 结束时间(如果有的话)&ftKernelMode,// 在内核模式下消耗的时间&ftUserMode);// 在用户模式下消耗的时间// 计算内核模式消耗的时间百分比DWORD dwPctKernel=::GetKernelModePercentage(ftKernelMode,// 在内核模式上消耗的时间ftUserMode);// 在用户模式下消耗的时间// 向用户显示进程的某些信息cout<< "process ID: " << pe.th32ProcessID<< ",EXE file:" << pe.szExeFile<< ",%d in Kernel mode: " << dwPctKernel << endl;// 消除句柄::CloseHandle(hProcess);}}// 转向下一个进程bMore=::Process32Next(hSnapshot,&pe);}if(found==FALSE){cout<<"当前系统没有这个可执行程序正在运行"<<endl;exit(0);}}清单1-3 核心态运行和用户态运行时间测试程序#include <stdio.h>main(){int i,j;while(1){for(i=0;i<1000;i++);for(j=1;j<1000;j++) printf(“enter kernel mode running.”);}}实验二进程管理1、实验目的1) 通过创建进程、观察正在运行的进程和终止进程的程序设计和调试操作，进一步熟悉操作系统的进程概念，理解Windows进程的“一生”。
计算机操作系统实验指导linux版王红玲源码
计算机操作系统实验指导linux版王红玲源码
摘要：
一、计算机操作系统实验指导linux 版简介
1.书名及作者
2.出版时间及出版社
二、实验指导内容概述
1.实验教程的目标
2.实验教程的主要内容
3.实验教程的特色
三、实验指导的使用建议
1.适合阅读对象
2.实验环境要求
3.阅读及实践方法
四、实验指导的评价
1.学术评价
2.学生评价
3.社会评价
正文：
计算机操作系统实验指导linux 版是由王红玲编著，于2010 年出版的一本实验教程。
该教程针对Linux 操作系统，旨在帮助读者深入了解操作系统原理，提高实际操作能力。
实验指导内容涵盖了Linux 系统的基本操作、系统配置、服务器搭建、网络管理、编程实践等方面。
全书共分为12 章，包括Linux 系统简介、常用命令、文件系统、系统管理、网络配置、Web 服务器、FTP 服务器、DNS 服务器、Linux 编程等。
每章都配有详细的实验步骤和丰富的实例，读者可以通过实践操作，更好地理解操作系统原理。
本书适合作为计算机相关专业操作系统课程的实验教材，也可供Linux 系统管理员和开发人员参考。
实验环境要求读者具备基本的Linux 操作系统知识，并安装有Linux 操作系统。
阅读时，建议按照章节顺序进行，先理解理论知识，再进行实践操作。
计算机操作系统实验指导linux 版受到了广泛的好评。
学者认为，该书内容丰富、实用性强，对操作系统课程的教学具有很好的辅助作用。
学生评价表示，通过该书的学习，能够快速掌握Linux 操作系统的使用方法和技巧。
操作系统实验指导书及代码
操作系统实验指导书及代码《操作系统》实验指导书目录实验环境 ................................................. 1 实验报告要求 ............................................. 1 实验一进程控制与处理机调度综合实验 ..................... 2 实验二存储管理与页面置换算法 (7)实验环境本课程实验硬件环境为PⅢ以上的处理器，带有显示器。
操作系统使用windows98以上操作系统，基本编程环境为Turbo C。
实验报告要求实验报告应包含以下内容：（1）实验题目（2）实验目的（3）实验环境（4）算法描述（5）程序源代码（6）出现的问题（7）对问题的解决方案（8）实验结果与结果分析（9）实验思考（学生对本次实验的收获的总结）实验一进程控制与处理机调度综合实验一、实验目的通过模拟进程控制方法及单处理机系统的进程调度，了解进程的结构，进程的创建与撤消，进程的组织及进程的状态及其转换，掌握进程调度策略。
二、实验学时4学时三、实验内容本实验为单机模拟进程调度算法，在程序设计时不需真正地建立线程或者进程。
实验模拟创建若干进程（人为输入或随机数产生），选择一种或几种单处理机的进程调度算法，如FCFS（先来先服务），SPF（短进程优先），RR（时间片轮转法），优先级算法等，模拟进行进程调度。
每进行一次调度，都打印一次运行进程、就绪队列、以及各个进程的PCB，并能在进程完成后及时撤消该进程。
四、算法描述1 进程及进程的运行状态进程是现代计算机中的基本要素，是系统分配资源和调度的基本单位。
进程与程序不同，进程是系统中动态的实体，有它的创建、运行和撤销的过程。
PCB块是系统感知进程存在的唯一实体。
进程的创建必须首先创建进程的PCB块，而进程的运行也伴随着PCB块的变化，进城撤销也要同时撤销它的PCB块。
所以本实验的任务就是通过模拟调度进程的PCB块来调度进程。
计算机操作系统实验指导linux版王红玲源码
计算机操作系统实验指导linux版王红玲源码操作系统实验是计算机科学专业学生必修的一门课程，通过实验可以增加学生对操作系统原理的理解和运用能力。
本文以Linux版王红祥操作系统实验指导为例，介绍实验的内容和相关源码。
一、实验内容王红祥操作系统实验主要包括以下几个方面的内容：1.操作系统的引导过程：通过编写汇编代码，实现在x86计算机上加载操作系统，并将CPU从实模式切换到保护模式。
2. 中断处理：实现Timer和UART中断的处理函数，并学习如何编写中断处理程序。
3.多进程管理：实现进程的创建、调度和切换，并学习如何用进程间通信的方式实现进程间的数据交换。
4.内存管理：实现内存的分配和回收，通过设计页表实现虚拟地址转换到物理地址。
5.文件系统：基于FAT12文件系统，实现文件的读取和写入功能，包括创建、删除和修改文件。
二、源码分析以下是王红祥操作系统实验中的一个源码例子，用于实现中断处理：```cvoid irq_handler(int irq)if (irq == TIMER_IRQ)} else if (irq == UART_IRQ)uart_handle(;}/*处理定时器中断的逻辑*/void uart_handle/*处理串口中断的逻辑*/int main/*设置中断处理函数*/set_irq_handler(IRQ0, irq_handler); set_irq_handler(IRQ1, irq_handler); /*启用中断*/enable_irq(IRQ0);enable_irq(IRQ1);/*主循环*/while (1)/*在这里执行其他的操作*/}return 0;```在main函数中，首先通过set_irq_handler函数设置了中断处理函数。
然后，通过enable_irq函数启用了IRQ0和IRQ1中断。
最后，采用死循环结构确保操作系统对中断的及时处理。
以上源码是王红祥操作系统实验中的一部分，通过学习和实践这些源码，可以更好地理解和掌握操作系统的原理和实现。
操作系统实验指导1
操作系统实验指导书楚雄师范学院计算机科学系操作系统课程组2011-9-20第一部分操作系统上机指导Linux操作系统环境：RedHat Enterprise Linux ES release 3 (Taroon Update 1) (2.4.21-9.EL)Red Flag Linux release 4.0 (HOT) (2.4)登录到系统常用命令练习：用root账号（超级用户）注册，口令为jkxroot（注意大小写）。
注册成功出现#号（超级用户系统提示符,普通用户的系统提示符为$）。
注销（退出）系统：logout 或exit3．练习使用命令ls（注意Linux命令区分大小写。
）使用ls 查看当前目录内容；使用ls 查看指定目录内容，如/目录，/etc目录使用ls –all 查看当前目录内容；使用dir 查看当前目录内容4．使用cd改变当前目录cd .. 回到上层目录；cd / 回到根目录5．pwd 显示当前路径6．建立目录mkdirmkdir 目录名；mkdir /home/s2001/newdir7．删除目录：rmdir；8．复制文件cp：如cp 文件名1 文件名29．移动文件或目录: mv10．删除文件rm11. 显示文件内容：more (分页显示);12. 显示文件：cat 文件名建立文件：cat >文件名，ctrl+d结束输入使用编辑器vi 编辑文件进入linux的文本模式之后，在命令行键入vi filename.c 然后回车。
下面作一些简单的解释：首先vi命令是打开vi编辑器。
后面的filename.c是用户即将编辑的c文件名字，注意扩展名字是.c；当然，vi编辑器功能很强，可以用它来编辑其它格式的文件，比如汇编文件，其扩展名字是.s；也可以直接用vi打开一个新的未命名的文件，当保存的时候再给它命名，只是这样做不很方便。
最基本的命令I ：当进入刚打开的文件时，不能写入信息，这时按一下键盘上的I键（insert），插入的意思，就可以进入编辑模式了。
计算机操作系统实验指导linux版王红玲源码
计算机操作系统实验指导linux版王红玲源码【原创版】目录一、计算机操作系统实验指导的意义和目的二、Linux 系统的概述和特点三、计算机操作系统实验指导 Linux 版的内容四、王红玲源码的介绍和应用五、如何进行计算机操作系统实验六、总结正文一、计算机操作系统实验指导的意义和目的计算机操作系统是计算机系统中最基本的系统软件之一，它管理计算机硬件资源和提供应用程序运行环境。
学习计算机操作系统对于计算机专业的学生来说是非常重要的，而通过实验来学习和理解计算机操作系统则是一种非常有效的方式。
计算机操作系统实验指导的目的是为了帮助学生通过实践来深入理解和掌握计算机操作系统的原理和实现。
二、Linux 系统的概述和特点Linux 是一种免费使用和自由传播的类 UNIX 操作系统，其内核由林纳斯·本纳第克特·托瓦兹于 1991 年首次发布。
Linux 系统具有多用户、多任务、支持多线程和多 CPU 的特点，能运行主要的 Unix 工具软件、应用程序和网络协议。
Linux 系统在服务器领域和开发领域受到广泛欢迎，很多程序员都认为掌握 Linux 是必备的技能。
三、计算机操作系统实验指导 Linux 版的内容计算机操作系统实验指导 Linux 版主要包括以下几个方面：1.Linux 系统的基本操作和配置：包括 Linux 系统的安装、配置和管理，以及 Linux 命令的使用和操作。
2.Linux 系统下的程序设计和开发：包括 Linux 系统下的 C 语言编程、Python 编程等。
3.Linux 系统下的网络配置和应用：包括 Linux 系统下的网络协议、网络配置和网络应用等。
4.Linux 系统下的数据库管理和应用：包括 Linux 系统下的 MySQL、MongoDB 等数据库的管理和应用。
四、王红玲源码的介绍和应用王红玲源码是一套非常实用的 Linux 系统教程，它包括 Linux 系统的基本操作、程序设计和开发、网络配置和应用、数据库管理和应用等方面的内容。
《操作系统》实验指导书
操作系统实验指导书专业：计算机科学与技术；软件工程课程名称：操作系统课程类别：专业必修课计算机与通信工程学院2009目录第1篇Linux操作系统使用 (1)实验1Linux系统的安装及基本操作 (1)实验2Linux 的常用命令与基本管理 (38)第2篇操作系统算法模拟 (53)实验1 银行家算法 (53)实验2 进程调度 (55)实验3 动态分区分配 (56)实验4 页式存储管理 (57)实验5 虚拟存储管理器的页面调度 (59)实验6 文件管理 (62)实验7 磁盘存储空间的分配与回收 (64)实验8 磁盘调度 (66)附录 (67)实验1报告写法 (67)实验2报告的写法 (67)算法模拟部分 (68)第1篇Linux操作系统使用实验1Linux系统的安装及基本操作一、实验目的1．掌握Red Hat Enterprise Linux 5的安装方法。
2．了解Linux操作系统的启动与登录方法。
3．掌握Red Hat Linux图形用户界面下的基本操作。
二、实验工具与设备1．实验工具：Red Hat Enterprise Linux 5光盘或镜像文件。
2．实验设备：计算机（带CD-ROM）一台。
三、实验预备知识虚拟机简介虚拟机，顾名思义就是虚拟出来的电脑，这个虚拟出来的电脑和真实的电脑几乎完全一样，所不同的是他的硬盘是在一个文件中虚拟出来的，所以你可以随意修改虚拟机的设置，而不用担心对自己的电脑造成损失。
虚拟机中有自己的CPU、主板、内存、BIOS、显卡、硬盘、光驱、软驱、网卡、声卡、串口、并口和US B等设备。
Vmware介绍Vmware是一个“虚拟PC”软件。
它使你可以在一台机器上同时运行二个或更多Windows、DOS、LINUX系统。
与“多启动”系统相比，VMWare采用了完全不同的概念。
多启动系统在一个时刻只能运行一个系统，在系统切换时需要重新启动机器。
VMWare是真正“同时”运行，多个操作系统在主系统的平台上，就象标准Wi ndows应用程序那样切换。
操作系统原理实验指导书(软件)
图 1.1地址转换模拟流程图
(5)缺页中断模拟
如果访问页不在主存且页表未满，则调入一页并打印页表情况；如果该页不在主存且页表已满，则产生缺页中断，模拟算法如图1.2所示。
二、实验内容
设计五个进程{P0，P1，P2，P3，P4}共享三类资源{A，B，C}的系统，{A，B，C}的资源数量分别为10，5，7。进程可动态地申请资源和释放资源，系统按各进程的申请动态地分配资源。要求程序具有显示和打印各进程的某一时刻的资源分配表和安全序列；显示和打印各进程依次要求申请的资源号以及为某进程分配资源后的有关资源数据。
为了清楚的观察诸进程的调度过程，程序应将每个时间片内的进程的情况显示出来，参照的具体格式如下：
RUNNING PROG: I
READY_QUEUE:->id1->id2
BLOCK_QUEUE:->id3->id4
三、实验性质
验证性
四、实验学时
2学时
五、实验环境
《C与C++程序设计学习与实验系统》
六、实验原理及步骤
三、实验性质
验证性
四、实验学时
2学时
五、实验环境
《C与C++程序设计学习与实验系统》
六、实验原理及步骤
1.进程pi提出资源申请时，系统执行下列步骤：
（1）若Request[i]≤Need[i],转（2）；
否则错误返回
（2）若Request[i]≤Available,
计算机操作系统实验指导汤小丹版源代码
计算机操作系统实验指导汤小丹版源代码```python#实验指导：操作系统进程调度算法实现#题目描述：#设计一个操作系统的进程调度算法，使得CPU能够合理地分配给各个进程时间片，并实现算法的模拟。
#要求：#1.设计进程调度算法#2.实现进程控制块#3.实现模拟CPU的运行过程#实验步骤：#1.定义进程控制块#进程控制块（PCB）存储了一个进程的相关信息，包括进程ID、优先级、进程状态等等。
以下是一个简单的PCB类的定义：class PCB:def __init__(self, pid, priority):self.pid = pidself.priority = priorityself.state = 'ready'#2.实现进程调度算法# 进程调度算法决定了CPU如何从就绪队列中选择下一个要执行的进程。
以下是一个简单的调度算法（Round-Robin算法）的实现：def schedule(processes):while True:for process in processes:if process.state == 'ready':print(f"Running process {process.pid}...")process.state = 'running'#3.实现CPU的模拟#在模拟CPU运行过程中，可以将每个进程表示为一个线程，通过调度算法选择要运行的线程，并模拟线程执行的过程。
import threadingclass CPU(threading.Thread):def __init__(self, process):threading.Thread.__init__(self)self.process = processdef run(self):print(f"CPU: Running process {self.process.pid}...")print(f"CPU: Process {self.process.pid} finished.") self.process.state = 'finished'#4.实验结果展示#定义几个进程process1 = PCB(1, 1)process2 = PCB(2, 2)process3 = PCB(3, 3)#将进程放入就绪队列processes = [process1, process2, process3]#调度进程schedule(processes)#模拟CPU运行for process in processes:cpu = CPU(process)cpu.startcpu.join#5.实验总结# 本次实验基于Python语言，实现了一个简单的操作系统进程调度算法模拟。
计算机操作系统实验指导linux版王红玲源码
计算机操作系统实验指导linux版王红玲源码（原创实用版）目录一、计算机操作系统实验指导概述1.1 计算机操作系统实验指导的目的和意义1.2 计算机操作系统实验指导的内容和特点1.3 计算机操作系统实验指导的适用对象和范围二、Linux 操作系统简介2.1 Linux 的历史和发展2.2 Linux 的特点和优势2.3 Linux 的应用领域三、计算机操作系统实验指导的具体内容3.1 实验篇3.1.1 实验目的和要求3.1.2 实验环境和工具3.1.3 实验内容和步骤3.2 课程设计篇3.2.1 课程设计目的和要求3.2.2 课程设计环境和工具3.2.3 课程设计题目和指导3.3 习题篇3.3.1 习题的目的和作用3.3.2 习题的类型和难度3.3.3 习题的答案和解析四、计算机操作系统实验指导的使用方法和建议4.1 实验方法和技巧4.2 学习方法和策略4.3 教学方法和建议五、计算机操作系统实验指导的评价和反馈5.1 实验指导的评价标准和方法5.2 实验指导的反馈和改进正文一、计算机操作系统实验指导概述计算机操作系统实验指导是为了帮助学生更好地理解和掌握计算机操作系统的原理和实现，提高学生的实际操作能力和解决问题的能力而编写的。
它对于学生学习计算机操作系统课程具有重要的意义和作用。
计算机操作系统实验指导的内容主要包括实验篇、课程设计篇和习题篇。
实验篇主要是通过实验让学生了解和熟悉计算机操作系统的基本原理和操作；课程设计篇则是通过课程设计让学生深入理解和掌握计算机操作系统的实现原理和方法；习题篇则是通过大量的习题训练学生的计算机操作系统知识。
计算机操作系统实验指导适用于计算机相关专业的学生，以及对计算机操作系统有兴趣和需求的人员。
二、Linux 操作系统简介Linux 是一款免费使用和自由传播的类 UNIX 操作系统，其内核由林纳斯·本纳第克特·托瓦兹于 1991 年首次发布。
操作系统实验指导完整版
操作系统实验指导适用课程：操作系统适用专业：计算机科学与技术软件工程目录实验环境的使用 (3)操作系统的启动 (11)进程的创建 (16)进程的同步 (22)时间片轮转调度 (29)分页存储器管理 (33)设备驱动程序 (40)FAT12文件系统 (46)实验环境的使用实验性质：验证建议学时：2学时一、实验目的●熟悉操作系统集成实验环境OS Lab的基本使用方法。
●练习编译、调试EOS操作系统内核以及EOS应用程序。
二、预备知识阅读《EOS实验指南》第一章，对EOS操作系统和集成实验环境有一个初步的了解。
三、实验内容3.1 启动OS Lab1.在安装有OS Lab的主机上，可以使用两种不同的方法来启动OS Lab：●在桌面上双击“Tevation OS Lab”图标。
●点击“开始”菜单，在“程序”中的“Tevation OS Lab”中选择“TevationOS Lab”。
2.OS Lab每次启动后都会首先弹出一个用于注册用户信息的对话框（可以选择对话框标题栏上的“帮助”按钮获得关于此对话框的帮助信息）。
在此对话框中填入学号和姓名后，点击“确定”按钮完成本次注册。
3.观察OS Lab主窗口的布局。
OS Lab主要由下面的若干元素组成：菜单栏、工具栏以及停靠在左侧和底部的各种工具窗口，余下的区域用来放置编辑器窗口。
3.2 学习OS Lab的基本使用方法通过练习使用OS Lab编写一个Windows控制台应用程序，熟悉OS Lab的基本使用方法（包括新建项目、生成项目、调试项目等）。
3.2.1 新建Windows控制台应用程序项目新建一个Windows控制台应用程序项目的步骤如下：1.在“文件”菜单中选择“新建”，然后单击“项目”。
2.在“新建项目”对话框中，选择项目模板“控制台应用程序(c)”。
3.在“名称”中输入新项目使用的文件夹名称“oslab”。
4.在“位置”中输入新项目保存在磁盘上的位置“C:\Test”。
计算机操作系统实验指导linux版王红玲源码
计算机操作系统实验指导linux版王红玲源码计算机操作系统实验指导（Linux版）导言：计算机操作系统是计算机系统中最重要的软件之一，负责管理计算机系统的硬件和软件资源，并为用户提供良好的使用环境。
为了帮助学生更好地理解操作系统的原理和实现，我们开设计算机操作系统实验课程，并提供一份针对Linux操作系统的实验指导。
本实验指导旨在帮助学生通过实际编程来探索和理解操作系统的原理和实现方式。
通过完成本实验，学生将能够熟悉Linux操作系统的基本功能和原理，并学会使用Linux的命令行界面和Shell编程。
同时，本实验还将引导学生通过源代码的阅读和分析，深入理解操作系统内部的工作原理。
实验一：Linux环境搭建在开始实验之前，我们首先需要搭建一个适合的Linux开发环境。
学生可以选择在个人电脑上安装Linux发行版，如Ubuntu或Fedora，也可以使用虚拟机软件，如VirtualBox或VMware，在Windows或Mac OS上安装Linux虚拟机。
实验二：Linux基本操作和Shell编程在本实验中，学生将通过完成一系列实际任务来熟悉Linux的基本操作和Shell编程。
任务包括使用命令行界面进行文件和目录操作、执行Shell脚本、配置系统环境等。
学生需要按照指导完成每个任务，并理解每个任务的目的和原理。
实验三：Linux系统调用和进程管理在本实验中，学生将学习和实现Linux系统调用和进程管理的功能。
学生需要阅读和分析Linux内核源代码中与系统调用和进程管理相关的部分，并完成一系列与之相关的实验任务。
任务包括编写和调试系统调用、创建和管理进程、实现进程间通信等。
实验四：Linux内存管理和文件系统在本实验中，学生将学习和实现Linux内存管理和文件系统的功能。
学生需要阅读和分析Linux内核源代码中与内存管理和文件系统相关的部分，并完成一系列与之相关的实验任务。
任务包括实现内存分配算法、设计和实现文件系统、调试和优化内存和文件系统的性能等。
操作系统实验一三报告+源码
实验一报告3．命令解释程序1）、目的：通过本实验熟悉UNIX或Linux操作系统及C语言。
熟悉系统调用的编程能力，程序中允许使用库函数。
2）、内容：利用C语言编写一个微型命令解释程序，接受并解释以下命令：⑴ dir 列当前目录⑵ cop 文件1 文件2 拷贝文件⑶ era文件名删除文件⑷ dis字符串显示字符串试验要求三：在命令解释程序中，我自定义了一个字符数组比较函数，用来比较输入的字符串是否合法，若合法，则调用shell 命令，然后还有一个字符分离函数，用来将命令和参数分开程序开始时就是从键盘接受输入存入缓存区，然后进行比较，比较成功就调用system函数执行试验源程序如下：#include <stdio.h>#include <string.h>#include <stdlib.h>int stringcmp(char a[],char b[],int i){int k=0;while(((a[k]!='\0')||(b[k]!='\0'))&&(k<=i)){if(a[k]==b[k])k++;else break;}if(((a[k]=='\0')&&(b[k]=='\0'))||(k>i))return 1;else return 0;}void stringcpy(char a[],char b[],int i,int k){while(b[k]!='\0'){a[i]=b[k];i++;k++;}}void main(){char dir[]="dir";char copy[]="copy ";char era[]="era ";char dis[]="dis ";char end[]="end";char input[50];char cp[30]={"cp "};char rm[30]={"rm "};char echo[30]={"echo "};printf(">");while(1){gets(input);if(stringcmp(dir,input,50)){system("ls");}else if(stringcmp(end,input,50)){system("quit");}else if(stringcmp(copy,input,4)){char parameter[20];stringcpy(parameter,input,0,5);system(strcat(cp,parameter));}else if(stringcmp(era,input,3)){char parameter[20];stringcpy(parameter,input,0,4);system(strcat(rm,parameter));}else if(stringcmp(dis,input,3)){char parameter[50];stringcpy(parameter,input,0,4);system(strcat(echo,parameter));}elseprintf("Invalid command,please try again!\n>");}}程序流程图如下：输入正确命令即可执行，如输入”dir”列出当前目录的所有文件和文件夹，运行”del ding “则会查找文件名为丁的文件，若找到，成功删除，若不存在，则显示"Invalid command,please try again!"。
操作系统实验_示例代码_linux
《计算机操作系统》实验指导苏州科技学院电子与信息工程系软件教研室二OO二年九月示例代码第一部分LINUX操作系统平台实验一命令解释程序示例程序minishell.c//文件名minishell.cpp//功能小型SHELL命令解释程序//开发环境#define true 1#define flase 0#include <stdio.h>#include <string.h>#include <stdlib.h>void main(){char cmdl[80];char *scwt[]={"exit","dir","time"};static int cmdnum=3; //可用的命令数char cmd[80];int j,n;while(true){printf("Please input command: ");gets(cmdl); //取命令行输入n=strcspn(cmdl," "); //取命令命令部分if (n>0||strlen(cmdl)>0){ strncpy(cmd,cmdl,n);cmd[n]='\0';for(j=0;j<cmdnum;j++)if (strcmp(cmd,scwt[j])==0)break;if (j==0) //是exit命令?exit(0);if (j<cmdnum) //其他合法命令{system(cmdl);continue;}printf("Bad command!\n"); //命令错}}}实验二进程管理fork()调用示例#include <stdio.h>main(){int p1,p2;while ((p1=fork())==-1);if (p1==0) //是子进程？putchar('b');else //父进程{putchar('a');}}实验三进程间通信1）pipe()调用示例#include<stdio.h>main(){int id,fd[2];char buf[50],s[50];pipe(fd);while ((id=fork())==-1);if (id==0){sprintf(buf,"Child is sending message!");write(fd[1],buf,50);exit(0);}else{wait(0);read(fd[0],s,50);printf("%s\n",s);exit(0);}}2）共享存储器示例shm_sample.c#include <stdio.h>#include <sys/types.h>#include <sys/ipc.h>#include <sys/shm.h>#define SEGSIZE 100main(int argc, char *argv[]){ key_t key;int shmid, cntr;char *segptr;if(argc == 1)usage(); /* Create unique key via call to ftok() */key = ftok(".", 'S');/* Open the shared memory segment - create if necessary */if((shmid = shmget(key, SEGSIZE, IPC_CREAT|IPC_EXCL|0666)) == -1){printf("Shared memory segment exists - opening as client\n");/* Segment probably already exists - try as a client */if((shmid = shmget(key, SEGSIZE, 0)) == -1){perror("shmget");exit(1);}}else{printf("Creating new shared memory segment\n");}/* Attach (map) the shared memory segment into the current process */if((segptr = shmat(shmid, 0, 0)) == -1){perror("shmat");exit(1);}switch(tolower(argv[1][0])){case 'w': writeshm(shmid, segptr, argv[2]);break;case 'r': readshm(shmid, segptr);break;case 'd': removeshm(shmid);break;case 'm': changemode(shmid, argv[2]);break;default: usage();}}writeshm(int shmid, char *segptr, char *text){strcpy(segptr, text);printf("Done...\n");}readshm(int shmid, char *segptr){printf("segptr: %s\n", segptr);}removeshm(int shmid){shmctl(shmid, IPC_RMID, 0);printf("Shared memory segment marked for deletion\n");}changemode(int shmid, char *mode){struct shmid_ds myshmds;/* Get current values for internal data structure */shmctl(shmid, IPC_STA T, &myshmds); /* Display old permissions */printf("Old permissions were: %o\n", myshmds.shm_perm.mode);/* Convert and load the mode */sscanf(mode, "%o", &myshmds.shm_perm.mode); /* Update the mode */ shmctl(shmid, IPC_SET, &myshmds);printf("New permissions are : %o\n", myshmds.shm_perm.mode);}usage(){fprintf(stderr, "shm_sample - A utility for tinkering with shared memory\n");fprintf(stderr, "\nUSAGE: shmtool (w)rite <text>\n");fprintf(stderr, " (r)ead\n");fprintf(stderr, " (d)elete\n");fprintf(stderr, " (m)ode change <octal mode>\n");exit(1);}3）消息队列使用示例(1) message.h/* message.h*/#ifndef MESSAGE_H#define MESSAGE_Hstruct mymsgbuf{long mtype;char mtext[256];};#endif(2) msg_server.c/*msg_server.c*/#include <stdio.h>#include <stdlib.h>#include <string.h>#include <signal.h>#include <sys/msg.h>#include <sys/ipc.h>#include "message.h"int msqid=-1;void sig_handle(int signo){/*软中断*/if (msqid!=-1)msgctl(msqid,IPC_RMID,NULL);printf("server quit...\n");exit(0);}int main(){struct mymsgbuf msgbuf;int left,right;char c;int length;if ((msqid=msgget(999,0666))!=-1){msgctl(msqid,IPC_RMID,NULL);}if ((msqid=msgget(999,IPC_CREAT|0666))==-1){printf("error:getmsg\n");exit(1);}signal(SIGINT,sig_handle); /*LINUX置软中断—CTRL-D*/for (;;){if (msgrcv(msqid,&msgbuf,256,1L,0)==-1){printf("error:msgrcv\n");exit(1);}length=strlen(msgbuf.mtext);left=0;right=length-1;while(left<right){c=msgbuf.mtext[left];msgbuf.mtext[left]=msgbuf.mtext[right];msgbuf.mtext[right]=c;left++;right--;}msgbuf.mtext[length]='\0';msgbuf.mtype=2;if (msgsnd(msqid,&msgbuf,256,0)==-1){printf("error:msgsnd");exit(1);}}msgctl(msqid,IPC_RMID,NULL);exit(0);}(3) msg_client.c/*msg_client.c*/#include <stdio.h>#include <stdlib.h>#include <string.h>#include <sys/msg.h>#include <sys/ipc.h>#include "message.h"int main(){struct mymsgbuf msgbuf;int msqid;if ((msqid=msgget(999,0666))==-1){printf("Server is not running\n");exit(1);}printf("Input a line:");scanf("%s",msgbuf.mtext);msgbuf.mtype=1;if (msgsnd(msqid,&msgbuf,256,0)==-1){printf("error:msgsnd\n");exit(1);}if (msgrcv(msqid,&msgbuf,256,2L,0)==-1){printf("error:msgrcv\n");exit(1);}printf("The reversed line is:%s\n",msgbuf.mtext);exit(0);}实验四存储管理示例程序(注意阅读并分析可能存在的问题)#define TRUE 1#define FALSE 0#define INV ALID -1#define null 0#define total_instruction 320 /*指令流长*/#define total_vp 32 /*虚页长*/#define clear_period 50 /*清零周期*/typedef struct{ /*页面结构*/ int pn,pfn,counter,time;}pl_type;pl_type pl[total_vp]; /*页面数组*/struct pfc_struct{ /*页面控制结构*/ int pn,pfn;struct pfc_struct *next;};typedef struct pfc_struct pfc_type;pfc_type pfc[total_vp],*freepf_head,*busypf_head,*busypf_tail;int diseffect,a[total_instruction];int page[total_instruction], offset[total_instruction];void initialize(int total_pf);void FIFO(int total_pf);void LRU(int total_pf);void OPT(int total_pf);void LFU(int total_pf);void NUR(int total_pf);#include <stdlib.h>#include <stdio.h>#include <time.h>main(){int S,i;srand( (unsigned)time( NULL ) );/* srand(getpid()*10);*//*由于每次运行时进程号不同，故可用来作为初始化随机数的"种子"*/S=(float)319*rand()/32767+1;for(i=0;i<total_instruction;i+=4) /*产生指令队列*/{a[i]=S; /*任选一指令访问点*/a[i+1]=a[i]+1; /*顺序执行一条指令*/a[i+2]=(float)a[i]*rand()/32767; /*执行前地址指令m'*/a[i+3]=a[i+2]+1; /*执行后地址指令*/S=(float)rand()*(318-a[i+2])/32767+a[i+2]+2;}for(i=0;i<total_instruction;i++) /*将指令序列变换成页地址流*/{page[i]=a[i]/10;offset[i]=a[i]%10;}for(i=4;i<=32;i++) /*用户内存工作区从4个页面到32个页面*/ {printf("%2d page frames",i);FIFO(i);LRU(i);OPT(i);LFU(i);NUR(i);printf("\n");}return(0);}//void FIFO(total_pf) /*FIFO（First In First Out) ALOGRITHM*/ //int total_pf; /*用户进程的内存页面数*/void FIFO(int total_pf)//int total_pf;{int i;pfc_type *p;initialize(total_pf);busypf_head=busypf_tail=NULL;for (i=0;i<total_instruction;i++){if (pl[page[i]].pfn==INV ALID){diseffect+=1;if (freepf_head==NULL){p=busypf_head->next;pl[busypf_head->pn].pfn=INV ALID;freepf_head=busypf_head;freepf_head->next=NULL;busypf_head=p;}p=freepf_head->next;freepf_head->next=NULL;freepf_head->pn=page[i];pl[page[i]].pfn=freepf_head->pfn;if (busypf_tail==NULL)busypf_head=busypf_tail=freepf_head;else{busypf_tail->next=freepf_head;busypf_tail=freepf_head;}freepf_head=p;}}printf(" FIFO:%6.4f",1-(float)diseffect/320);}void LRU(int total_pf)//int total_pf;{int min,minj,i,j,present_time;initialize(total_pf);present_time=0;for(i=0;i<total_instruction;i++){if (pl[page[i]].pfn=INV ALID){diseffect++;if (freepf_head==NULL){min=32767;for(j=0;j<total_vp;j++)if (min>pl[j].time && pl[j].pfn!=INV ALID){min=pl[j].time;minj=j;}freepf_head=&pfc[pl[minj].pfn];pl[min].pfn=INV ALID;pl[min].time=-1;freepf_head->next=NULL;}pl[page[i]].pfn=freepf_head->pfn;pl[page[i]].time=present_time;freepf_head=freepf_head->next;}elsepl[page[i]].time=present_time;present_time++;}printf(" LRU:%6.4f",1-(float)diseffect/320);}void NUR(int total_pf)//int total_pf;{int i,j,dp,cont_flag,old_dp;// pfc_type *t;initialize(total_pf);dp=0;for(i=0;i<total_instruction;i++){if (pl[page[i]].pfn==INV ALID) /*页面失效*/{diseffect++;if (freepf_head==NULL) /*无空闲页面*/{cont_flag=TRUE;old_dp=dp;while(cont_flag)if (pl[dp].counter==0&&pl[dp].pfn!=INV ALID)cont_flag=FALSE;else{dp++;if (dp==total_vp)dp=0;if (dp==old_dp)for (j=0;j<total_vp;j++)pl[j].counter=0;}freepf_head=&pfc[pl[dp].pfn];pl[dp].pfn=INV ALID;freepf_head->next=NULL;}pl[page[i]].pfn=freepf_head->pfn;freepf_head=freepf_head->next;}elsepl[page[i]].counter=1;if (i%clear_period==0)for(j=0;j<total_vp;j++)pl[j].counter=0;}printf(" NUR:%6.4f",1-(float)diseffect/320);}void OPT(int total_pf) /*OPT（Optional Replacement) ALOGRITHM*/ //int total_pf;{int i,j,max,maxpage,d,dist[total_vp];pfc_type *t;initialize(total_pf);for(i=0;i<total_instruction;i++){if (pl[page[i]].pfn==INV ALID){diseffect++;if (freepf_head==NULL){for(j=0;j<total_vp;j++)if (pl[j].pfn!=INV ALID)dist[j]=32767;elsedist[j]=0;d=1;for(j=i+1;j<total_instruction;j++){if (pl[page[j]].pfn!=INV ALID)dist[page[j]]=d;d++;}max=-1;for(j=0;j<total_vp;j++)if (max<dist[j]){max=dist[j];maxpage=j;}freepf_head=&pfc[pl[maxpage].pfn];freepf_head->next=NULL;pl[maxpage].pfn=INV ALID;}pl[page[i]].pfn=freepf_head->pfn;freepf_head=freepf_head->next;}}printf(" OPT:%6.4f",1-(float)diseffect/320);}void LFU(int total_pf) /*LFU（leat Frequently Used) ALOGRITHM*/ //int total_pf;{int i,j,min,minpage;pfc_type *t;initialize(total_pf);for(i=0;i<total_instruction;i++){if (pl[page[i]].pfn==INV ALID){diseffect++;if (freepf_head==NULL){min=32767;for(j=0;j<total_vp;j++){if (min>pl[j].counter&&pl[j].pfn!=INV ALID){min=pl[j].counter;minpage=j;}pl[j].counter=0;}freepf_head=&pfc[pl[minpage].pfn];pl[minpage].pfn=INV ALID;freepf_head=freepf_head->next;}elsepl[page[i]].counter++;}}printf(" LFU:%6.4f",1-(float)diseffect/320);}void initialize(int total_pf) /*初始化相关数据结构*///int total_pf; /*用户进程的内存页面数*/{int i;diseffect=0;for(i=0;i<total_vp;i++){pl[i].pn=i;pl[i].pfn=INV ALID; /*置页面控制结构中的页号，页面为空*/pl[i].counter=0; /*页面控制结构中的访问次数为0，时间为-1*/pl[i].time=-1;}for(i=1;i<total_pf;i++){pfc[i-1].next=&pfc[i];pfc[i-1].pfn=i-1;} /*建立pfc[i-1] 和pfc[i]之间的链接*/pfc[total_pf-1].next=NULL;pfc[total_pf-1].pfn=total_pf-1;freepf_head=&pfc[0]; /*空页面队列的头指针为pfc[0]*/}实验五设备管理一、实验步骤:LINUX中，模块可以用C语言编写，用gcc编译成目标文件（不进行链接，作为*.o文件存在），为此需要在gcc命令行里加上-c的参数。
操作系统源代码
操作系统源代码添加内核模块一、实验目的：学习Linux模块的基本概念和原理，学习内核模块编程的基本技术，利用内核模块编程访问进程描述符，操作内核的基本数据结构，加深对进程的理解。
二、实验内容：设计一个模块，功能是列出系统中所有内核线程的程序名、PID 号和进程状态。
主要步骤：阅读内核源代码，了解进程描述符task_struct中与本实验有关的成员项，以及访问进程队列的宏for_each_process；分析内核模块实例，掌握内核模块的主要构成；阅读Makefile文件，理解内核模块编译、加载过程；编写readprocess模块，在屏幕上输出进程信息。
三、实验平台：虚拟机：VMWare9操作系统：Ubuntu12.04编辑器：Gedit | Vi四、实例代码：模块代码：/*hello.c*/#include#include#includestatic int hello_init(void){printk(KERN_ALERT "hello world enter\n");return 0;}static void hello_exit(void){printk(KERN_ALERT "hello world exit\n");}module_init(hello_init);module_exit(hello_exit);MODULE_LICENSE("GPL");Makefile文件代码：ifneq ($(KERNELRELEASE),)obj-m:=hello.oelseKDIR:= /lib/modules/3.2.0-23-generic-pae/build PWD:= $(shell pwd)default:$(MAKE) -C $(KDIR) M=$(PWD) modules clean:$(MAKE) -C $(KDIR) M=$(PWD) cleanendif与本次试验相关的内核代码：linux/sched.h文件中：#define TASK_RUNNING 0#define TASK_INTERRUPTIBLE 1#define TASK_UNINTERRUPTIBLE 2#define __TASK_STOPPED 4#define __TASK_TRACED 8#define EXIT_ZOMBIE 16#define EXIT_DEAD 32#define TASK_DEAD 64#define TASK_WAKEKILL 128#define TASK_WAKING 256#define TASK_PARKED 512struct task_struct {volatile long state; /* -1 unrunnable, 0 runnable, >0 stopped */struct list_head tasks;struct mm_struct *mm;pid_t pid;pid_t tgid;struct task_struct __rcu *real_parent; /* real parent process */ struct task_struct __rcu *parent; /* recipient of SIGCHLD, wait4() reports */char comm[TASK_COMM_LEN]; /* executable name excluding path */}宏for_each_process(p)它的功能是扫描整个进程链表：#define for_each_process(p) \ for (p = &init_task ; (p = next_task(p)) != &init_task ; )使用方法：struct task_struct *p;for_each_process(p){//对p指向的进程描述符进行操作}。
- 1、下载文档前请自行甄别文档内容的完整性，平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益，请联系客服反馈,我们会尽快为您处理(人工客服工作时间：9:00-18:30)。
华东交通大学软件学院操作系统实验报告专业: 计算机科学与技术姓名: 林庆达学号: 31030051382005-6试验一进程调度一、实验目的:编写和调试一个进程调度程序，以加深对进程的概念及进程调度算法的理解。
二、实验内容：以两种典型算法为例说明实现的算法(一)、最高优先数优先的调度算法1、实验原理进程调度算法：采用最高优先数优先的调度算法（即把处理机分配给优先数最高的进程）和先来先服务算法。
每个进程有一个进程控制块（PCB）表示。
进程控制块可以包含如下信息：进程名、优先数、到达时间、需要运行时间、已用CPU时间、进程状态等等。
进程的优先数及需要的运行时间可以事先人为地指定（也可以由随机数产生）。
进程的到达时间为进程输入的时间。
进程的运行时间以时间片为单位进行计算。
每个进程的状态可以是就绪W（Wait）、运行R（Run）、或完成F（Finish）三种状态之一。
就绪进程获得CPU后都只能运行一个时间片。
用已占用CPU时间加1来表示。
如果运行一个时间片后，进程的已占用CPU时间已达到所需要的运行时间，则撤消该进程，如果运行一个时间片后进程的已占用CPU时间还未达所需要的运行时间，也就是进程还需要继续运行，此时应将进程的优先数减1（即降低一级），然后把它插入就绪队列等待CPU。
每进行一次调度程序都打印一次运行进程、就绪队列、以及各个进程的PCB，以便进行检查。
重复以上过程，直到所有进程都完成为止。
2、源代码：#include "stdio.h"#include <stdlib.h>#include <conio.h>#define getpch(type) (type*)malloc(sizeof(type))#define NULL 0struct pcb { /* 定义进程控制块PCB */char name[10]; /*定义进程名称*/char state; /*进程状态*/int super; /*优先数*/int ntime; /*需要运行的时间*/int rtime; /*已占用的CPU时间*/struct pcb* link;}*ready=NULL,*p;typedef struct pcb PCB; /*pcb表*/sort() /* 建立对进程进行优先级排列函数*/{ PCB *first, *second;int insert=0;if((ready==NULL)||((p->super)>(ready->super))) /*优先级最大者,插入队首*/ { p->link=ready;ready=p;}else /* 进程比较优先级,插入适当的位置中*/{ first=ready;second=first->link;while(second!=NULL){ if((p->super)>(second->super)) /*若插入进程比当前进程优先数大,*/ { /*插入到当前进程前面*/p->link=second;first->link=p;second=NULL;insert=1;}else /* 插入进程优先数最低,则插入到队尾*/{ first=first->link;second=second->link;}}if(insert==0) first->link=p;}}input() /* 建立进程控制块函数*/{ i nt i,num;clrscr(); /*清屏*/printf("\n 请输入进程号?");scanf("%d",&num);for(i=0;i<num;i++){ printf("\n 进程号No.%d:\n",i);p=getpch(PCB);printf("\n 输入进程名:");scanf("%s",p->name);printf("\n 输入进程优先数:");scanf("%d",&p->super);printf("\n 输入进程运行时间:");scanf("%d",&p->ntime);printf("\n");p->rtime=0;p->state='w';p->link=NULL;sort(); /* 调用sort函数*/}}int space(){ int l=0; PCB* pr=ready;while(pr!=NULL){ l++;pr=pr->link;}return(l);}disp(PCB * pr) /*建立进程显示函数,用于显示当前进程*/{ printf("\n qname \t state \t super \t ndtime \t runtime \n");printf("|%s\t",pr->name);printf("|%c\t",pr->state);printf("|%d\t",pr->super);printf("|%d\t",pr->ntime);printf("|%d\t",pr->rtime);printf("\n");}check() /* 建立进程查看函数，检查等待队列的进程是否进入就绪队列*/{ PCB* pr;printf("\n **** 当前正在运行的进程是:%s",p->name); /*显示当前运行进程*/ disp(p);pr=ready;printf("\n ****当前就绪队列状态为:\n"); /*显示就绪队列状态*/while(pr!=NULL){ disp(pr);pr=pr->link;}}destroy() /*建立进程撤消函数(进程运行结束,撤消进程)*/{ printf("\n 进程[%s] 已完成.\n",p->name);free(p);}running() /* 建立进程就绪函数(进程运行时间到,置就绪状态*/{ (p->rtime)++;if(p->rtime==p->ntime)destroy(); /* 调用destroy函数*/else{ (p->super)--;p->state='w';sort(); /*调用sort函数*/}}main() /*主函数*/{ int len, h=0;char ch;input();len=space();while((len!=0)&&(ready!=NULL)){ ch=getchar();h++;printf("\n The execute number:%d \n",h);p=ready;ready=p->link;p->link=NULL;p->state='R';check();running();printf("\n 按任一键继续......");ch=getchar();}printf("\n\n 进程已经完成.\n");ch=getchar();}3、运行结果：请输入进程号？5进程号No.0：输入进程名：A输入进程优先数：2输入进程运行时间：1进程号No.1：输入进程名：B输入进程优先数：3输入进程运行时间：1进程号No.2：输入进程名：C输入进程优先数：1输入进程运行时间：1进程号No.3：输入进程名：D输入进程优先数：4输入进程运行时间：1进程号No.4：输入进程名：E输入进程优先数：5输入进程运行时间：1The execute number:1****当前正在运行的进程是：EQname state super ndtime runtime E R 5 1 0****当前就绪队列状态为：Qname state super ndtime runtime D w 4 1 0B w 3 1 0A w 2 1 0C w 1 1 0进程[E]已完成按任一键继续……The execute number:2****当前正在运行的进程是：DQname state super ndtime runtime D R 4 1 0****当前就绪队列状态为：Qname state super ndtime runtime B w 3 1 0A w 2 1 0C w 1 1 0进程[D]已完成按任一键继续……The execute number:3****当前正在运行的进程是：BQname state super ndtime runtime B R 3 1 0****当前就绪队列状态为：Qname state super ndtime runtime A w 2 1 0C w 1 1 0进程[B]已完成按任一键继续……The execute number:4****当前正在运行的进程是：AQname state super ndtime runtimeA R 2 1 0****当前就绪队列状态为：Qname state super ndtime runtimeC w 1 1 0进程[A]已完成按任一键继续……The execute number:5****当前正在运行的进程是：cQname state super ndtimeruntimec R 1 1 0****当前就绪队列状态为：进程[C]已完成按任一键继续……进程已经完成(二)、简单轮转法1、实验原理在分时系统中，都毫无例外采用时间片轮转法。
在一种简单的轮转法中，系统将所有就绪进程按FIFO规则排成一个队列，把CPU分配给队首进程，并规定它执行一给定的时间如100ms，称此时间间隔为时间片。
当时间片完成时，系统产生一个时钟中断，剥夺该进程的执行，将它送至就绪队列的末尾，并把处理机分配给就绪队列的新队首进程，同样也让它执行一个时间片。
这样，就绪队列中的所有进程均可获得一个时间片的处理机而运行。
就绪队列中的进程在依次执行时，可能发生以下三种情况：(1)进程未用完一个时间片就结束，这时系统应提前调度；(2)进程在执行过程中提出I/O请求而阻塞，系统应将它放入相应的阻塞队列并引起调度；(3)进程完成一个时间片后尚未完成，系统应将它重新放到就绪队列的末尾，等待下次执行。