操作系统实验
操作系统试验指导
—. 课程的性质、目的和任务
操作系统在整个计算机系统软件中占有中心地位。其作用是对计算机系统进行统一的调度和管理，提供各种强有力的系统服务，为用户创造既灵活又方便的使用环境。本课程是计算机及应用专业的一门专业主干课和必修课。通过本课程的学习,使学生掌握操作系统的基本概念、设计原理及实施技术,具有分析操作系统和设计、实现、开发实际操作系统的能力。
二. 实验的意义和目的
操作系统是计算机专业学生的一门重要的专业课程。操作系统质量对整个计算机系统的性能和用户对计算机的使用有重大的影响。一个优良的操作系统能极大地扩充计算机系统的功能，充分发挥系统中各种设备的使用效率，提高系统工作的可靠性。由于操作系统涉及计算机系统中各种软硬件资源的管理，内容比较繁琐，具有很强的实践性。要学好这门课程，必须把理论与实践紧密结合，才能取得较好的学习效果。培养计算机专业的学生的系统程序设计能力，是操作系统课程的一个非常重要的环节。通过操作系统上机实验，可以培养学生程序设计的方法和技巧，提高学生编制清晰、合理、可读性好的系统程序的能力，加深对操作系统课程的理解。使学生更好地掌握操作系统的基本概念、基本原理、及基本功能,具有分析实际操作系统、设计、构造和开发现代操作系统的基本能力。
三.实验运行环境及上机前的准备
实验运行环境: C语言编程环境
上机前的准备工作包括：
●按实验指导书要求事先编好程序；
●准备好需要输入的中间数据；
●估计可能出现的问题；
●预计可能得到的运行结果。
四. 实验内容及安排
实验内容包括进程调度、银行家算法、页式地址重定位模拟，LRU算法模拟和先来先服务算法五个实验。每个实验介绍了实习的目的要求、内容和方法。
实验一、进程调度试验
[目的要求]
用高级语言编写和调试一个进程调度程序，以加深对进程的概念及进程调度算法的
理解．
[准备知识]
一、基本概念
1、进程的概念；
2、进程的状态和进程控制块；
3、进程调度算法；
二、进程调度
1、进程的状态
2、进程的结构——PCB
进程都是由一系列操作(动作)所组成，通过这些操作来完成其任务。因此，不同的进
程，其内部操作也不相同。在操作系统中，描述一个进程除了需要程序和私有数据之外，
最主要的是需要一个与动态过程相联系的数据结构，该数据结构用来描述进程的外部特性
(名字、状态等)以及与其它进程的联系(通信关系)等信息，该数据结构称为进程控制块
(PCB ，Process Control Block)。
进程控制块PCB 与进程一一对应，PCB 中记录了系统所需的全部信息、用于描述进
程情况所需的全部信息和控制进程运行所需的全部信息。因此，系统可以通过进程的PCB
来对进程进行管理。
[试验内容]
设计一个有 N 个进程共行的进程调度程序。
进程调度算法：采用最高优先数优先的调度算法（即把处理机分配给优先数最高的进
程）和先来先服务算法。每个进程有一个进程控制块（ PCB ）表示。进程控制块可以包
含如下信息：进程名、优先数、到达时间、需要运行时间、已用CPU 时间、进程状态等
等。 进程的优先数及需要的运行时间可以事先人为地指定（也可以由随机数产生）。进程
的到达时间为进程输入的时间。进程的运行时间以时间片为单位进行计算。每个进程的状
态可以是就绪 W （Wait ）、运行R （Run ）、或完成F （Finish ）三种状态之一。就绪进程
获得 CPU 后都只能运行一个时间片。用已占用CPU 时间加1来表示。如果运行一个时
间片后，进程的已占用 CPU 时间已达到所需要的运行时间，则撤消该进程，如果运行一
I/O
某事件被解除（I/O 完成）
理机分配给进程
个时间片后进程的已占用CPU时间还未达所需要的运行时间，也就是进程还需要继续运行，此时应将进程的优先数减1（即降低一级），然后把它插入就绪队列等待CPU。每进行一次调度程序都打印一次运行进程、就绪队列、以及各个进程的PCB，以便进行检查。重复以上过程，直到所要进程都完成为止。
调度算法的流程图如下:
进程调度源程序如下：
jingchendiaodu.cpp
#include "stdio.h"
#include
#include
#define getpch(type) (type*)malloc(sizeof(type))
#define NULL 0
struct pcb { /* 定义进程控制块PCB */
char name[10];
char state;
int super;
int ntime;
int rtime;
struct pcb* link;
}*ready=NULL,*p;
typedef struct 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() /* 建立进程控制块函数*/
{
int i,num;
clrscr(); /*清屏*/
printf("\n 请输入进程号?");
scanf("%d",&num);
for(i=0;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(); } 实验二、银行家算法 （一）目的和要求 银行家算法是由Dijkstra设计的最具有代表性的避免死锁的算法。本实验要求用高级语言编写一个银行家的模拟算法。通过本实验可以对预防死锁和银行家算法有更深刻的认识。 （二）实验内容 1、设置数据结构 包括可利用资源向量（Availiable）,最大需求矩阵（Max）,分配矩阵（Allocation）,需求矩阵（Need） 2、设计安全性算法 设置工作向量Work 表示系统可提供进程继续运行可利用资源数目，Finish 表示系统是否有足够的资源分配给进程 （三）实验环境 1、pc 2、vc++ （四）、程序源代码： /*子函数声明*/ int Isprocessallover(); //判断系统中的进程是否全部运行完毕 void Systemstatus(); //显示当前系统中的资源及进程情况 int Banker(int ,int *); //银行家算法 void Allow(int ,int *); //若进程申请不导致死锁，用此函数分配资源 void Forbidenseason(int ); //若发生死锁，则显示原因 /*全局变量*/ int Availiable[3]={3,3,2}; //初始状态，系统可用资源量 int Max[5][3]={{7,5,3},{3,2,2},{9,0,2},{2,2,2},{4,3,3}}; //各进程对各资源的最大需求量 int Allocation[5][3]={{0,1,0},{2,0,0},{3,0,2},{2,1,1},{0,0,2}}; //初始状态，各进程占有资源量 int Need[5][3]={{7,4,3},{1,2,2},{6,0,0},{0,1,1},{4,3,1}}; //初始状态时，各进程运行完毕，还需要的资源量 int over[5]={0,0,0,0,0}; //标记对应进程是否得到所有资源并运行完毕 #include /*主函数*/ void main() { int process=0; //发出请求的进程 int decide=0; //银行家算法的返回值 int Request[3]={0,0,0}; //申请的资源量数组 int sourcenum=0; //申请的各资源量 /*判断系统中进程是否全部运行完毕*/ step1: if(Isprocessallover()==1) { cout<<"系统中全部进程运行完毕！"; return; } /*显示系统当前状态*/ Systemstatus(); /*人机交互界面*/ step2: cout<<"\n输入发出请求的进程（输入“0”退出系统）: "; cin>>process; if(process==0) { cout<<"放弃申请,退出系统！"; return; } if(process<1||process>5||over[process-1]==1) { cout<<"系统无此进程！\n"; goto step2; } cout<<"此进程申请各资源（A，B，C）数目：\n"; for(int h=0;h<3;h++) { cout< cin>>sourcenum; Request[h]=sourcenum; } /*用银行家算法判断是否能够进行分配*/ decide=Banker(process,Request); if (decide==0) { /*将此进程申请资源分配给它*/ Allow(process,Request); goto step1; } else { /*不能分配，显示原因*/ Forbidenseason(decide); goto step2; } } /*子函数Isprocessallover( )的实现*/ int Isprocessallover() { int processnum=0; for(int i=0;i<5;i++) { /*判断每个进程是否运行完毕*/ if(over[i]==1) processnum++; } if(processnum==5) /*系统中全部进程运行完毕*/ return 1; else return 0; } /*子函数Systemstatus( )的实现*/ void Systemstatus() { cout<<"此刻系统中存在的进程：\n"; for(int i=0;i<5;i++) { if(over[i]!=1) cout<<"P"< } cout< cout<<"此刻系统可利用资源（单位：个）：\n"; cout<<"A B C\n"; for(int a=0;a<3;a++) { cout< } cout< cout<<"此刻各进程已占有资源如下（单位：个）: \n" <<" A B C\n"; for(int b=0;b<5;b++) { if(over[b]==1) continue; cout<<"P"< for(int c=0;c<3;c++) cout< cout< } cout<<"各进程运行完毕还需各资源如下（单位：个）:\n" <<" A B C\n"; for(int f=0;f<5;f++) { if(over[f]==1) continue; cout<<"P"< for(int g=0;g<3;g++) cout< cout< } } /*子函数Banker(int ,int &)的实现*/ int Banker(int p,int *R) { int num=0; //标记各资源是否能满足各进程需要int Finish[5]={0,0,0,0,0}; //标记各进程是否安全运行完毕 int work[5]={0,0,0,0,0}; //用于安全检查 int AvailiableTest[3]; //用于试分配 int AllocationTest[5][3]; //同上 int NeedTest[5][3]; //同上 /*判断申请的资源是否大于系统可提供的资源总量*/ for(int j=0;j<3;j++) { if(*(R+j)>Availiable[j]) /*返回拒绝分配原因*/ return 1; } /*判断该进程申请资源量是否大于初始时其申明的需求量*/ for(int i=0;i<3;i++) { if(*(R+i)>Need[p-1][i]) /*返回拒绝原因*/ return 2; } /*为检查分配的各数据结构赋初值*/ for(int t=0;t<3;t++) { AvailiableTest[t]=Availiable[t]; } for(int u=0;u<5;u++) { for(int v=0;v<3;v++) { AllocationTest[u][v]=Allocation[u][v]; } } for(int w=0;w<5;w++) { for(int x=0;x<3;x++) { NeedTest[w][x]=Need[w][x]; } } /*进行试分配*/ for(int k=0;k<3;k++) //修改NeedTest[] { AvailiableTest[k]-=*(R+k); AllocationTest[p-1][k]+=*(R+k); NeedTest[p-1][k]-=*(R+k); } /*检测进程申请得到满足后，系统是否处于安全状态*/ for(int l=0;l<3;l++) { work[l]=AvailiableTest[l]; } for(int m=1;m<=5;m++) { for(int n=0;n<5;n++) { num=0; /*寻找用此刻系统中没有运行完的进程*/ if(Finish[n]==0&&over[n]!=1) { for(int p=0;p<3;p++) { if(NeedTest[n][p]<=work[p]) num++; } if(num==3) { for(int q=0;q<3;q++) { work[q]=work[q]+AllocationTest[n][q]; } Finish[n]=1; } } } } for(int r=0;r<5;r++) { if(Finish[r]==0&&over[r]!=1) /*返回拒绝分配原因*/ return 3; } return 0; } /*子函数Allow(int ,int &)的实现*/ void Allow(int p,int *R) { cout<<"可以满足申请！"; static int overnum; /*对进程所需的资源进行分配*/ for(int t=0;t<3;t++) { Availiable[t]=Availiable[t]-*(R+t); Allocation[p-1][t]=Allocation[p-1][t]+*(R+t); Need[p-1][t]=Need[p-1][t]-*(R+t); } /*分配后判断其是否运行完毕*/ overnum=0; for(int v=0;v<3;v++) { if(Need[p-1][v]==0) overnum++; } if(overnum==3) { /*此进程运行完毕，释放其占有的全部资源*/ for(int q=0;q<3;q++) Availiable[q]=Availiable[q]+Allocation[p-1][q]; /*标记该进程运行完毕*/ over[p-1]=1; cout<<"进程P"< } } /*子函数Forbidenseason(int )的实现*/ void Forbidenseason(int d) { cout<<"不能满足申请，此进程挂起，原因为：\n"; switch (d) { case 1:cout<<"申请的资源量大于系统可提供的资源量！";break; case 2:cout<<"申请的资源中有某种资源大于其声明的需求量！";break; case 3:cout<<"若满足申请，系统将进入不安全状态，可能导致死锁！"; } } 实验三、页式地址重定位模拟 一、实验目的： 1、用高级语言编写和调试模拟实现页式地址重定位。 2、加深理解页式地址重定位技术在多道程序设计中的作用和意义。 二、实验原理： 当进程在CPU上运行时，如指令中涉及逻辑地址时，操作系统自动根据页长得到页号和页内偏移，把页内偏移拷贝到物理地址寄存器，再根据页号，查页表，得到该页在内存中的块号，把块号左移页长的位数，写到物理地址寄存器。 三、实验内容： 1、设计页表结构 2、设计地址重定位算法 3、有良好的人机对话界面 四、程序源代码： #define pagesize 1024 #define pagetablelength 64 /*系统页表*/ const int pagetable[pagetablelength]={0,42,29,15,45,31,44,43, 41,28,1,30,12,24,6,32, 14,27,13,46,7,33,10,22, 40,2,51,11,39,23,49,50, 26,16,25,4,47,17,3,48, 52,36,58,35,57,34,21,63, 5,37,18,8,62,56,20,54, 60,19,38,9,61,55,59,53}; #include #include void main() { int logicaladdress=0; int pagenum=0; int w=0; cout<<"系统页号对应块号情况（页号——>块号）：\n"; for(int i=0;i<64;i++) { cout< if(i%8==7) cout< } cout< cin>>logicaladdress; pagenum=logicaladdress/pagesize; //求页号 w=logicaladdress%pagesize; //求页内偏移地址 if(pagenum>pagetablelength) //判断是否跃界 { cout<<"本次访问的地址已超出进程的地址空间，系统将产生越界中断！\n"; return; } cout<<"对应的物理地址为（十进制）：\n"< 二、程序调试： 调试数据一： 系统页号对应块号情况（页号——>块号）： 0--> 0 1-->42 2-->29 3-->15 4-->45 5-->31 6-->44 7-->43 8-->41 9-->28 10--> 1 11-->30 12-->12 13-->24 14--> 6 15-->32 16-->14 17-->27 18-->13 19-->46 20--> 7 21-->33 22-->10 23-->22 24-->40 25--> 2 26-->51 27-->11 28-->39 29-->23 30-->49 31-->50 32-->26 33-->16 34-->25 35--> 4 36-->47 37-->17 38--> 3 39-->48 40-->52 41-->36 42-->58 43-->35 44-->57 45-->34 46-->21 47-->63 48--> 5 49-->37 50-->18 51--> 8 52-->62 53-->56 54-->20 55-->54 56-->60 57-->19 58-->38 59--> 9 60-->61 61-->55 62-->59 63-->53 请输入逻辑地址（十进制）： 2500 对应的物理地址为（十进制）： 30148 Press any key to continue 调试数据二： 系统页号对应块号情况（页号——>块号）： 0--> 0 1-->42 2-->29 3-->15 4-->45 5-->31 6-->44 7-->43 8-->41 9-->28 10--> 1 11-->30 12-->12 13-->24 14--> 6 15-->32 16-->14 17-->27 18-->13 19-->46 20--> 7 21-->33 22-->10 23-->22 24-->40 25--> 2 26-->51 27-->11 28-->39 29-->23 30-->49 31-->50 32-->26 33-->16 34-->25 35--> 4 36-->47 37-->17 38--> 3 39-->48 40-->52 41-->36 42-->58 43-->35 44-->57 45-->34 46-->21 47-->63 48--> 5 49-->37 50-->18 51--> 8 52-->62 53-->56 54-->20 55-->54 56-->60 57-->19 58-->38 59--> 9 60-->61 61-->55 62-->59 63-->53 请输入逻辑地址（十进制）： 765497 本次访问的地址已超出进程的地址空间，系统将产生越界中断！ Press any key to continue 实验四、FIFO算法模拟 一、实验目的 一个作业有多个进程，处理机只分配固定的主存页面供该作业执行。往往页面数小于进程数，当请求调页程序调进一个页面时，可能碰到主存中并没有空闲块的情况，此时就产生了在主存中淘汰哪个页面的情况。本实验要求模拟FIFO算法 二、实验原理 此算法的实质是，总是选择在主存中居留最长时间的页面淘汰。理由是：最早调入主存的页，其不再被访问的可能性最大。 三、实验环境 1、pc 2、vc++ 四、程序源代码： #define MAXSIZE 20 #include void main() { int label=0; //标记此页是否已经装入内存 int input=0; //用于输入作业号 int worknum=0; //记录作业个数 int storesize=0; //系统分配的存储块数 int interrupt=0; //中断次数 int quence[MAXSIZE]; //队列，FIFO算法的主要数据结构 int workstep[MAXSIZE]; //用于记录作业走向 /*初始化*/ for(int i=0;i { quence[i]=0; workstep[i]=0; } cout<<"请输入存储区块数："; cin>>storesize; cout<<"请输入作业走向（输入0结束）：\n"; for(int j=0;j { cout<<"页面号："< cin>>input; workstep[j]=input; if(input==0) { cout<<"输入结束！\n"; break; } worknum++; } if(workstep[0]==0) { cout<<"未输入任何作业，系统将退出！\n"; return; } cout<<"置换情况如下：\n"; for(int k=0;k { label=0; /*看队列中是否有相等的页号或空位置*/ for(int l=0;l { /*是否有相等的页号*/ if(quence[l]==workstep[k]) { cout<<"内存中有"< label=1; //标记此页面已装入内存 break; } /*是否有空位置*/ if(quence[l]==0) { quence[l]=workstep[k]; cout<<"发生中断,但内存中有空闲区，"< interrupt++; label=1; break; } } /*上述情况都不成立则调出对首，将调入页面插入对尾*/ if(label==0) { cout<<"发生中断，将"< interrupt++; for(int m=0;m { quence[m]=quence[m+1]; } quence[storesize-1]=workstep[k]; } } cout<<"作业"< } 二、程序调试： 调试一： 请输入存储区块数：3 请输入作业走向（输入0结束）： 页面号1：4 页面号2：3 页面号3：2 页面号4：1 页面号5：4 页面号6：3 页面号7：5 页面号8：4 页面号9：3 页面号10：2 页面号11：1 页面号12：5 页面号13：0 输入结束！ 置换情况如下： 发生中断,但内存中有空闲区，4号页面直接调入！ 发生中断,但内存中有空闲区，3号页面直接调入！ 发生中断,但内存中有空闲区，2号页面直接调入！ 发生中断，将4号页面调出，1号装入！ 发生中断，将3号页面调出，4号装入！ 发生中断，将2号页面调出，3号装入！ 发生中断，将1号页面调出，5号装入！ 内存中有4号页面，无须中断！ 内存中有3号页面，无须中断！ 发生中断，将4号页面调出，2号装入！ 发生中断，将3号页面调出，1号装入！ 内存中有5号页面，无须中断！ 作业12个，中断9次，缺页率：75% Press any key to continue 调试二： 请输入存储区块数：4 请输入作业走向（输入0结束）： 页面号1：4 页面号2：3 页面号3：2 页面号4：1 页面号5：4 页面号6：3 页面号7：5 页面号8：4 页面号9：3 页面号10：2 页面号11：1 页面号12：5 页面号13：0 输入结束！ 置换情况如下： 发生中断,但内存中有空闲区，4号页面直接调入！发生中断,但内存中有空闲区，3号页面直接调入！发生中断,但内存中有空闲区，2号页面直接调入！发生中断,但内存中有空闲区，1号页面直接调入！内存中有4号页面，无须中断！ 内存中有3号页面，无须中断！ 发生中断，将4号页面调出，5号装入！ 发生中断，将3号页面调出，4号装入！ 发生中断，将2号页面调出，3号装入！ 发生中断，将1号页面调出，2号装入！ 发生中断，将5号页面调出，1号装入！ 发生中断，将4号页面调出，5号装入！ 作业12个，中断10次，缺页率：83.3333% Press any key to continue 实验五、LRU算法模拟 一、实验目的和要求 用高级语言模拟页面置换算法LRU，加深对LRU算法的认识。 二、实验原理 其基本原理为：如果某一个页面被访问了，它很可能还要被访问；相反，如果它长时间不被访问，再最近未来是不大可能被访问的。 三、实验环境 1、pc 2、vc++ 四、程序源代码： #define MAXSIZE 20 #include void main() { int input=0; //用于输入作业号 int worknum=0; //输入的作业个数 int storesize=0; //系统分配的存储区块数 int interrupt=0; //缺页中断次数 int stack[MAXSIZE]; //栈，LRU算法的主要数据结构int workstep[MAXSIZE]; //记录作业走向 /*初始化*/ for(int i=0;i { stack[i]=0; workstep[i]=0; } cout<<"请输入存储区块数："; cin>>storesize; cout<<"请输入作业的页面走向（输入0结束）：\n"; for(int j=0;j { cout<<"页面号"< cin>>input; workstep[j]=input; if(input==0) { cout<<"输入结束！\n"; break; } worknum++; } if(workstep[0]==0) 计算机操作系统实验报告 实验内容： P、V原语的模拟实现 实验类型：验证型 指导教师：毕国堂 专业班级： 姓名： 学号： 实验地点：东6E507 实验时间：2017/10/23 一、实验目的 1.理解信号量相关理论 2.掌握记录型信号量结构 3.掌握P、V原语实现机制 二、实验内容 1.输入给定的代码 2.进行功能测试并得出证正确结果 三、实验要求 1.分析signal和wait函数功能模块 ●Signal函数 在进行资源增加时，首先判断增加的资源是否存在，如果不存在则报错 并结束函数；如果存在则将需要增加的资源数量加一，然后再判断增加 后的资源数是否大于0，如果大于0则表示之前等待队列为空，没有需 要分配的进程；如果增加后的资源不大于0，表示之前等待队列中存在 进程，则将队首的进程取出并将资源分给该进程。 ●Wait 函数 在执行wait函数时，先判断请求的资源和进程是否存在，如果不存在则 报错提示；如果存在则将对应资源的资源数减一，然后判断减少后的资 源数是否小于0，如果小于0，表示该资源等待队列为空，可直接将资源 分配给请求的进程；如果不小于0则表示之前资源的等待队列不为空， 则将请求的进程插在等待队列最后。 2.画出signal和wait函数流程图 3.撰写实验报告 四、实验设备 1.PC机1台安装visual c++ 6.0 五、测试 1.首先将所有的资源分配完 2.这时再请求资源时就会出现等待现象 3.此时增加一个资源s0，则进程1对s0的等待结束直接获取资源s0 4.当再增加资源s0、s1时则进程1也结束对资源s1的等待，并且s0资源 为有空闲状态 六、实验思考 1.如何修改wait操作，使之能一次申请多个信号量？ wait函数传入一个进程号和多个资源名，在wait函数中使用循环依 // tjty.cpp : Defines the entry point for the console application. // #include "stdafx.h" #include block[i].timer = 0; } page = new pageInfor[Psize]; for(i=0; i 广州大学学生实验报告 1、实验目的 1.1、掌握进程的概念，明确进程的含义 1.2、认识并了解并发执行的实质 2.1、掌握进程另外的创建方法 2.2、熟悉进程的睡眠、同步、撤消等进程控制方法 3.1、进一步认识并发执行的实质 3.2、分析进程竞争资源的现象，学习解决进程互斥的方法 4.1、了解守护进程 5.1、了解什么是信号 5.2、INUX系统中进程之间软中断通信的基本原理 6.1、了解什么是管道 6.2、熟悉UNIX/LINUX支持的管道通信方式 7.1、了解什么是消息 7.2、熟悉消息传送的机理 8.1、了解和熟悉共享存储机制 二、实验内容 1.1、编写一段程序，使用系统调用fork( )创建两个子进程。当此程序运行时，在系统 中有一个父进程和两个子进程活动。让每一个进程在屏幕上显示一个字符：父进程显示'a'，子进程分别显示字符'b'和字符'c'。试观察记录屏幕上的显示结果，并分析原因。 1.2、修改上述程序，每一个进程循环显示一句话。子进程显示'daughter …'及 'son ……'，父进程显示'parent ……'，观察结果，分析原因。 2.1、用fork( )创建一个进程，再调用exec( )用新的程序替换该子进程的内容 2.2、利用wait( )来控制进程执行顺序 3.1、修改实验（一）中的程序2，用lockf( )来给每一个进程加锁，以实现进程之间的互斥 3.2、观察并分析出现的现象 4.1、写一个使用守护进程(daemon)的程序，来实现： 创建一个日志文件/var/log/Mydaemon.log ； 每分钟都向其中写入一个时间戳(使用time_t的格式) ； 5.1、用fork( )创建两个子进程，再用系统调用signal( )让父进程捕捉键盘上来的中断信号（即按^c键）；捕捉到中断信号后，父进程用系统调用kill( )向两个子进程发出信号，子进程捕捉到信号后分别输出下列信息后终止： Child process1 is killed by parent! Child process2 is killed by parent! 父进程等待两个子进程终止后，输出如下的信息后终止： Parent process is killed! 5.2、用软中断通信实现进程同步的机理 一、实验目的 通过对进程调度算法的设计，深入理解进程调度的原理。 进程是程序在一个数据集合上运行的过程，它是系统进行资源分配和调度的一个独立单位。 进程调度分配处理机，是控制协调进程对CPU的竞争，即按一定的调度算法从就绪队列中选中一个进程，把CPU的使用权交给被选中的进程。 进程通过定义一个进程控制块的数据结构（PCB）来表示；每个进程需要赋予进程ID、进程到达时间、进程需要运行的总时间的属性；在RR中，以1为时间片单位；运行时，输入若干个进程序列，按照时间片输出其执行序列。 二、实验环境 VC++6.0 三、实验内容 实现短进程优先调度算法（SPF）和时间片轮转调度算法（RR） [提示]： (1) 先来先服务（FCFS）调度算法 原理：每次调度是从就绪队列中，选择一个最先进入就绪队列的进程，把处理器分配给该进程，使之得到执行。该进程一旦占有了处理器，它就一直运行下去，直到该进程完成或因发生事件而阻塞，才退出处理器。 将用户作业和就绪进程按提交顺序或变为就绪状态的先后排成队列，并按照先来先服务的方式进行调度处理，是一种最普遍和最简单的方法。它优先考虑在系统中等待时间最长的作业，而不管要求运行时间的长短。 按照就绪进程进入就绪队列的先后次序进行调度，简单易实现，利于长进程，CPU繁忙型作业，不利于短进程，排队时间相对过长。 (2) 时间片轮转调度算法RR 原理：时间片轮转法主要用于进程调度。采用此算法的系统，其程序就绪队列往往按进程到达的时间来排序。进程调度按一定时间片（q）轮番运行各个进程. 进程按到达时间在就绪队列中排队，调度程序每次把CPU分配给就绪队列首进程使用一个时间片，运行完一个时间片释放CPU，排到就绪队列末尾参加下一轮调度，CPU分配给就绪队列的首进程。 固定时间片轮转法： 1 所有就绪进程按 FCFS 规则排队。 2 处理机总是分配给就绪队列的队首进程。 3 如果运行的进程用完时间片，则系统就把该进程送回就绪队列的队尾，重新排队。 4 因等待某事件而阻塞的进程送到阻塞队列。 5 系统把被唤醒的进程送到就绪队列的队尾。 可变时间片轮转法： 1 进程状态的转换方法同固定时间片轮转法。 2 响应时间固定，时间片的长短依据进程数量的多少由T = N × （ q + t ）给出的关系调整。 3 根据进程优先级的高低进一步调整时间片，优先级越高的进程，分配的时间片越长。 多就绪队列轮转法： (3) 算法类型 (4)模拟程序可由两部分组成，先来先服务（FCFS）调度算法，时间片轮转。流程图如下: 重庆大学 学生实验报告 实验课程名称操作系统原理 开课实验室DS1501 学院软件学院年级2013专业班软件工程2 班学生姓名胡其友学号20131802 开课时间2015至2016学年第一学期 总成绩 教师签名洪明坚 软件学院制 《操作系统原理》实验报告 开课实验室：年月日学院软件学院年级、专业、班2013级软件工 程2班 姓名胡其友成绩 课程名称操作系统原理 实验项目 名称 指导教师洪明坚 教师 评语教师签名：洪明坚年月日 1．实验目的： ?进入实验环境 –双击expenv/setvars.bat ?检出（checkout）EPOS的源代码 –svn checkout https://www.360docs.net/doc/e61259408.html,/svn/epos ?编译及运行 –cd epos/app –make run ?清除所有的临时文件 –make clean ?调试 –make debug ?在“Bochs Enhanced Debugger”中，输入“quit”退出调试 –调试指令，请看附录A 2．实验内容： ?编写系统调用“time_t time(time_t *loc)” –功能描述 ?返回从格林尼治时间1970年1月1日午夜起所经过的秒数。如果指针loc 非NULL，则返回值也被填到loc所指向的内存位置 –数据类型time_t其实就是long ?typedef long time_t; 3．实验步骤： ?Kernel space –K1、在machdep.c中，编写系统调用的实现函数“time_t sys_time()”，计算用户秒数。需要用到 ?变量g_startup_time，它记录了EPOS启动时，距离格林尼治时间1970年1午夜的秒数 ?变量g_timer_ticks 上海电力学院 计算机操作系统原理 实验报告 题目：动态链接库的建立与调用 院系：计算机科学与技术学院 专业年级：信息安全2010级 学生姓名：李鑫学号：20103277 同组姓名：无 2012年11 月28 日上海电力学院 实验报告 课程名称计算机操作系统原理实验项目线程的同步 姓名李鑫学号20103277 班级2010251班专业信息安全 同组人姓名无指导教师姓名徐曼实验日期2012/11/28 实验目的和要求： (l)了解Windows内存管理机制，理解页式存储管理技术。 (2)熟悉Windows内存管理基本数据结构。 (3)掌握Windows内存管理基本API的使用。 实验原理与内容 使用Windows系统提供的函数和数据结构显示系统存储空间的使用情况，当内存和虚拟存储空间变化时，观察系统显示变化情况。 实验平台与要求 能正确使用系统函数GlobalMemoryStatus()和数据结构MEMORYSTATUS了解系统内存和虚拟空间使用情况，会使用VirtualAlloc()函数和VirtualFree()函数分配和释放虚拟存储空间。 操作系统：Windows 2000或Windows XP 实验平台：Visual Studio C++ 6.0 实验步骤与记录 1、启动安装好的Visual C++ 6.0。 2、选择File->New，新建Win32 Console Application程序, 由于内存分配、释放及系统存储 空间使用情况均是Microsoft Windows操作系统的系统调用，因此选择An application that support MFC。单击确定按钮，完成本次创建。 3、创建一个支持MFC的工程，单击完成。 学生学号 实验课成绩 武汉理工大学 学生实验报告书 实验课程名称 计算机操作系统 开 课 学 院 计算机科学与技术学院 指导老师姓名 学 生 姓 名 学生专业班级 2016 — 2017 学年第一学期 实验三 内存管理 一、设计目的、功能与要求 1、实验目的 掌握内存管理的相关内容，对内存的分配和回收有深入的理解。 2、实现功能 模拟实现内存管理机制 3、具体要求 任选一种计算机高级语言编程实现 选择一种内存管理方案：动态分区式、请求页式、段式、段页式等 能够输入给定的内存大小，进程的个数，每个进程所需内存空间的大小等 能够选择分配、回收操作 内购显示进程在内存的储存地址、大小等 显示每次完成内存分配或回收后内存空间的使用情况 二、问题描述 所谓分区，是把内存分为一些大小相等或不等的分区，除操作系统占用一个分区外，其余分区用来存放进程的程序和数据。本次实验中才用动态分区法，也就是在作业的处理过程中划分内存的区域，根据需要确定大小。 动态分区的分配算法：首先从可用表/自由链中找到一个足以容纳该作业的可用空白区，如果这个空白区比需求大，则将它分为两个部分，一部分成为已分配区，剩下部分仍为空白区。最后修改可用表或自由链，并回送一个所分配区的序号或该分区的起始地址。 最先适应法：按分区的起始地址的递增次序，从头查找，找到符合要求的第一个分区。 最佳适应法：按照分区大小的递增次序，查找，找到符合要求的第一个分区。 最坏适应法：按分区大小的递减次序，从头查找，找到符合要求的第一个分区。 三、数据结构及功能设计 1、数据结构 定义空闲分区结构体，用来保存内存中空闲分区的情况。其中size属性表示空闲分区的大小，start_addr表示空闲分区首地址，next指针指向下一个空闲分区。 //空闲分区 typedef struct Free_Block { int size; int start_addr; struct Free_Block *next; } Free_Block; Free_Block *free_block; 定义已分配的内存空间的结构体，用来保存已经被进程占用了内存空间的情况。其中pid作为该被分配分区的编号，用于在释放该内存空间时便于查找。size表示分区的大小，start_addr表示分区的起始地址，process_name存放进程名称，next指针指向下一个分区。 //已分配分区的结构体 typedef struct Allocate_Block { int pid; int size; int start_addr; char process_name[PROCESS_NAME_LEN]; struct Allocate_Block *next; } Allocate_Block; 2、模块说明 2.1 初始化模块 对内存空间进行初始化，初始情况内存空间为空，但是要设置内存的最大容量，该内存空间的首地址，以便之后新建进程的过程中使用。当空闲分区初始化 评分： SHANGHAI UNIVERSITY 操作系统实验报告 学院计算机工程与科学 专业计算机科学与技术 学号 学生姓名 《计算机操作系统》实验一报告 实验一题目：操作系统的进程调度 姓名：张佳慧学号 :12122544 实验日期： 2015.1 实验环境： Microsoft Visual Studio 实验目的： 进程是操作系统最重要的概念之一，进程调度又是操作系统核心的主要内容。本实习要求学生独立地用高级语言编写和调试一个简单的进程调度程序。调度算法可任意选择或自行设计。例如，简单轮转法和优先数法等。本实习可加深对于进程调度和各种调度算法的理解。实验内容： 1、设计一个有n个进程工行的进程调度程序。每个进程由一个进程控制块（PCB）表示。进程控制块通常应包含下述信息：进程名、进程优先数、进程需要运行的时间、占用CPU的时间以及进程的状态等，且可按调度算法的不同而增删。 2、调度程序应包含2～3种不同的调度算法，运行时可任意选一种，以利于各种算法的分析比较。 3、系统应能显示或打印各进程状态和参数的变化情况，便于观察诸进程的调度过程。 操作过程： 1、本程序可选用优先数法或简单轮转法对五个进程进行调度。每个进程处于运行R(run)、就绪W(wait)和完成F(finish)三种状态之一，并假设起始状态都是就绪状态W。为了便于处理，程序进程的运行时间以时间片为单位计算。进程控制块结构如下： 进程控制块结构如下： PCB 进程标识数 链指针 优先数/轮转时间片数 占用 CPU 时间片数 进程所需时间片数 进程状态 进程控制块链结构如下： 其中：RUN—当前运行进程指针； HEAD—进程就绪链链首指针； TAID—进程就绪链链尾指针。2、算法与框图 (1) 优先数法。进程就绪链按优先数大小从高到低排列，链首进程首先投入运行。每过一个时间片，运行进程所需运行的时间片数减 1，说明它已运行了一个时间片，优先数也减 3，理由是该进程如果在一个时间片中完成不了，优先级应该降低一级。接着比较现行进程和就绪链链首进程的优先数，如果仍是现行进程高或者相同，就让现行进程继续进行，否则，调度就绪链链首进程投入运行。原运行进程再按其优先数大小插入就绪链，且改变它们对应的进程状态，直至所有进程都运行完各自的时间片数。 (2) 简单轮转法。进程就绪链按各进程进入的先后次序排列，进程每次占用处理机的轮转时间按其重要程度登入进程控制块中的轮转时间片数记录项（相当于优先数法的优先数记录项位置）。每过一个时间片，运行进程占用处理机的时间片数加 1，然后比较占用处理机的时间片数是否与该进程的轮转时间片数相等，若相等说明已到达轮转时间，应将现运行进程排到就绪链末尾，调度链首进程占用处理机，且改变它们的进程状态，直至所有进程完成各自的时间片。 (3) 程序框图 实验三进程与线程 问题： 进程是具有独立功能的程序关于某个数据集合上的一次运行活动，是系统进行资源分配和调度的独立单位，具有动态性、并发性、独立性、异步性和交互性。然而程序是静态的，并且进程与程序的组成不同，进程＝程序＋数据＋PCB，进程的存在是暂时的，程序的存在是永久的；一个程序可以对应多个进程，一个进程可以包含多个程序。当操作系统引入线程的概念后，进程是操作系统独立分配资源的单位，线程成为系统调度的单位，与同一个进程中的其他线程共享程序空间。 本次实验主要的目的是： （1）理解进程的独立空间； （2）加深对进程概念的理解，明确进程和程序的区别； （3）进一步认识并发执行的实质； （4）了解红帽子（Linux）系统中进程通信的基本原理。 （5）理解线程的相关概念。 要求： 1、请查阅资料，掌握进程的概念，同时掌握进程创建和构造的相关知识和线程创建和 构造的相关知识，了解C语言程序编写的相关知识； （1）进程： 进程（Process）是计算机中的程序关于某数据集合上的一次运行活动，是系统进行资源分配和调度的基本单位，是操作系统结构的基础。程序是指令、数据及其组织形式的描述，进程是程序的实体。进程的概念主要有两点：第一，进程是一个实体。每一个进程都有它自己的地址空间，一般情况下，包括文本区域（text region）、数据区域（data region）和堆栈（stack region）。文本区域存储处理器执行的代码；数据区域存储变量和进程执行期间使用的动态分配的内 存；堆栈区域存储着活动过程调用的指令和本地变量。第二，进程是一个“执行中的程序”。程序是一个没有生命的实体，只有处理器赋予程序生命时（操作系统执行之），它才能成为一个活动的实体，我们称其为进程。 （2）进程的创建和构造: 进程简单来说就是在操作系统中运行的程序，它是操作系统资源管理的最小单位。但是进程是一个动态的实体，它是程序的一次执行过程。进程和程序的区别在于：进程是动态的，程序是静态的，进程是运行中的程序，而程序是一些保存在硬盘上的可执行代码。新的进程通过克隆旧的程序（当前进程）而建立。fork() 和clone()（对于线程）系统调用可用来建立新的进程。 （3）线程的创建和构造： 线程也称做轻量级进程。就像进程一样，线程在程序中是独立的、并发的执行路径，每个线程有它自己的堆栈、自己的程序计数器和自己的局部变量。但是，与独立的进程相比，进程中的线程之间的独立程度要小。它们共享内存、文件句柄和其他每个进程应有的状态。 线程的出现也并不是为了取代进程，而是对进程的功能作了扩展。进程可以支持多个线程，它们看似同时执行，但相互之间并不同步。一个进程中的多个线程共享相同的内存地址空间，这就意味着它们可以访问相同的变量和对象，而且它们从同一堆中分配对象。尽管这让线程之间共享信息变得更容易，但你必须小心，确保它们不会妨碍同一进程里的其他线程。 线程与进程相似，是一段完成某个特定功能的代码，是程序中单个顺序的流控制，但与进程不同的是，同类的多个线程是共享同一块内存空间和一组系统资源的，而线程本身的数据通常只有微处理器的寄存器数据，以及一个供程序执行时使用的堆栈。所以系统在产生一个线程，或者在各个线程之间切换时，负担要比进程小得多，正因如此，线程也被称为轻型进程（light-weight process）。一个进程中可以包含多个线程。 2、理解进程的独立空间的实验内容及步骤 操作系统实验报告 集团企业公司编码：（LL3698-KKI1269-TM2483-LUI12689-ITT289- 实验二进程调度1．目的和要求 通过这次实验，理解进程调度的过程，进一步掌握进程状态的转变、进程调度的策略，进一步体会多道程序并发执行的特点，并分析具体的调度算法的特点，掌握对系统性能的评价方法。 2．实验内容 阅读教材《计算机操作系统》第二章和第三章，掌握进程管理及调度相关概念和原理。 编写程序模拟实现进程的轮转法调度过程，模拟程序只对PCB进行相应的调度模拟操作，不需要实际程序。假设初始状态为：有n个进程处于就绪状态，有m个进程处于阻塞状态。采用轮转法进程调度算法进行调度(调度过程中，假设处于执行状态的进程不会阻塞)，且每过t个时间片系统释放资源，唤醒处于阻塞队列队首的进程。 程序要求如下： 1）输出系统中进程的调度次序； 2）计算CPU利用率。 3．实验环境 Windows操作系统、VC++6.0 C语言 4设计思想： （1）程序中进程可用PCB表示，其类型描述如下： structPCB_type { intpid;//进程名 intstate;//进程状态 2——表示“执行”状态 1——表示“就绪”状态 0——表示“阻塞”状态 intcpu_time;//运行需要的CPU时间（需运行的时间片个数） } 用PCB来模拟进程； （2）设置两个队列，将处于“就绪”状态的进程PCB挂在队列ready中；将处于“阻塞”状态的进程PCB挂在队列blocked中。队列类型描述如下： structQueueNode{ structPCB_typePCB; StructQueueNode*next; } 并设全程量： structQueueNode*ready_head=NULL,//ready队列队首指针 *ready_tail=NULL,//ready队列队尾指 针 实验三操作系统进程管理 一、实验目的 1) 掌握系统进程的概念，加深对Linux / UNIX进程管理的理解。 2) 学会使用ps命令和选项。 3) 列出当前shell中的进程。 4) 列出运行在系统中的所有进程。 5) 根据命令名搜索特定的进程。 6) 使用kill命令终止进程。 7) 根据用户名查找和终止进程。 二、实验内容和相应的答案截图，三、实验结果分析 步骤1：创建一个普通用户（参见实验二），以普通用户身份登录进入GNOME。 步骤2：打开一个“终端”窗口（参见实验二）。 步骤3：回顾系统进程概念，完成以下填空： 1) Linux系统中，几乎每一个启动的进程，都会由内核分配一个唯一的__PID__进程标识符，用于跟踪从进程启动到进程结束。 2) 当启动新进程的时候，内核也给它们分配系统资源，如__内存_和__CPU_。 3) 永远不向父进程返回输出的进程叫做__僵进程__。 4) 由父进程派生出来的进程叫做____子___进程。 5) ___父_进程是一个派生另一个进程的进程。 6) 运行用于提供服务的Linux系统进程是_______________。 7) 如果父进程在子进程之前结束，它创建了一个______________进程。 步骤4：回顾ps命令和信息。基本的ps命令显示当前shell中的进程信息，用户只能够查看当前终端窗口中初始化的进程。输入ps命令，将结果填入表3-3中。 表3-3 实验记录 下面，在当前终端窗口中，练习使用给出的每个选项的ps命令。 输入ps -f 命令，显示运行在系统中的某个进程的完全信息，填入表3-4中。 表3-4 实验记录 步骤5：列出系统中运行的所有进程。 输入ps -ef 命令，显示运行在系统中的各个进程的完全信息。执行该命令，并与ps –f 命令的输出结果对照，一致吗？有何不同？ 答：不一致，后者显示了所有进程的完全可用信息，多了很多。 分析当前终端窗口中的输出结果，记录下来用于写实验报告。 a. 显示了多少个进程？答：59 b. 进程ID的PID是什么？ c. 启动进程的命令(CMD) 是什么？答：sched d. 请观察，什么命令的PID号是1？答：init[5] e. 执行ps –ef >aaa命令，将ps命令的输出送到文本文件aaa。再次运行cat aaa | wc命令，计算进程的数目。其中，cat是显示文本文件命令。“|”是管道命令，就是将前一个命令的输出作为后一个命令的输入。wc 命令用来计算文本的行数，第一个数字显示的是行的数目，可以用来计算进程的数目。计算出进程数目并做记录。 执行man ps命令，可以打开Linux用户命令手册。了解ps命令的用法。输入wq命令可退出用户手册的阅读。man命令可以执行吗？结果如何？ 答：Man ps时出现 实验4 进程控制 1、实验目的 （1）通过对WindowsXP进行编程，来熟悉和了解系统。 （2）通过分析程序，来了解进程的创建、终止。 2、实验工具 （1）一台WindowsXP操作系统的计算机。 （2）计算机装有Microsoft Visual Studio C++6.0专业版或企业版。 3、预备知识 （3）·CreateProcess（）调用：创建一个进程。 （4）·ExitProcess（）调用：终止一个进程。 4、实验编程 （1）编程一利用CreateProcess()函数创建一个子进程并且装入画图程序(mspaint.exe)。阅读该程序,完成实验任务。源程序如下： # include < stdio.h > # include < windows.h > int main(VOID) ﹛STARTUPINFO si; PROCESS INFORMA TION pi; ZeroMemory(&si,sizeof(si)); Si.cb=sizeof(si); ZeroMemory(&pi,sizeof(pi)); if(!CreateProcess(NULL, “c: \ WINDOWS\system32\ mspaint.exe”, NULL, NULL, FALSE, 0, NULL, NULL, &si,&pi)) ﹛fprintf(stderr,”Creat Process Failed”); return—1; ﹜ WaitForSingleObject(pi.hProcess,INFINITE); Printf(“child Complete”); CloseHandle(pi.hProcess); CloseHandle(pi hThread); ﹜ 青岛理工大学课程实验报告 算法描述及实验步骤 功能：共享存储区的附接。从逻辑上将一个共享存储区附接到进程的虚拟地址空间上。用于建立调用进程与由标识符shmid指定的共享内存对象之间的连接。 系统调用格式：virtaddr=shmat(shmid,addr,flag) 该函数使用头文件如下： #include 调 试 过 程 及 实 验 结 果 运行： 运行后： 总 结 （对实验结果进行分析，问题回答，实验心得体会及改进意见） 虽然对pipe()、msgget()、msgsnd()、msgrcv()、msgctl()、shmget()、shmat()、 shmdt()、shmctl()的功能和实现过程有所了解，但是运用还是不熟练，过去没 见过，所以运行了一个简单的程序。 利用管道机制、消息缓冲队列、共享存储区机制进行进程间的通信，加深了对 其了解。 （1）管道通信机制，同步的实现过程：当写进程把一定数量的数据写入pipe， 便去睡眠等待，直到读进程取走数据后，再把它唤醒。当读进程读一空pipe 时，也应睡眠等待，直到写进程将数据写入管道后，才将之唤醒，从而实现进 程的同步。 管道通信的特点：A管道是半双工的，数据只能向一个方向流动；需要双方通 信时，需要建立起两个管道；B. 只能用于父子进程或者兄弟进程之间（具有亲 缘关系的进程）；C.单独构成一种独立的文件系统：管道对于管道两端的进程而 《操作系统》实验报告 实验序号： 4 实验项目名称：进程控制 Printf(“child Complete”); CloseHandle(pi.hProcess); CloseHandle(pi hThread); ﹜ 修改后: #include 实验任务:写出程序的运行结果。 4．正在运行的进程 （2）、编程二下面给出了一个使用进程和操作系统版本信息应用程序(文件名为4-5.cpp)。它利用进程信息查询的API函数GetProcessVersion()与GetVersionEx()的共同作用。确定运行进程的操作系统版本号。阅读该程序并完成实验任务。 #include 许昌学院 《操作系统》实验报告书学号： 姓名：闫金科 班级：14物联网工程 成绩: 2016年02月 实验一Linux的安装与配置 一、实验目的 1.熟悉Linux系统的基本概念，比如Linux发行版、宏内核、 微内核等。 2.掌握Linux系统的安装和配置过程，初步掌握Linux系统的 启动和退出方法。 3.熟悉Linux系统的文件系统结构，了解Linux常用文件夹的 作用。 二、实验内容 1.从网络上下载VMware软件和两个不同Linux发行版镜像文 件。 2.安装VMware虚拟机软件。 3.在VMware中利用第一个镜像文件完成第一个Linux的安装， 期间完成网络信息、用户信息、文件系统和硬盘分区等配 置。 4.在VMware中利用第二个镜像文件完成第二个Linux的安装， 并通过LILO或者GRUB解决两个操作系统选择启动的问题。 5.启动Linux系统，打开文件浏览器查看Linux系统的文件结 构，并列举出Linux常用目录的作用。 三、实验过程及结果 1、启动VMware，点击新建Linux虚拟机，如图所示： 2、点击下一步，选择经典型，点击下一步在选择客户机页面选择Linux，版本选择RedHatEnterpriseLinux5，如图所示： 3、点击下一步创建虚拟机名称以及所要安装的位置，如图所示： 4、点击下一步，磁盘容量填一个合适大小，此处选择默认值大小10GB，如图所示： 5、点击完成，点击编辑虚拟机设置，选择硬件选项中的CD-ROM（IDE...）选项，在右侧连接中选择“使用ISO镜像（I）”选项，点击“浏览”，找到Linux的镜像文件，如图所示： 6点击确定按钮后，点击启动虚拟机按钮，来到Linux的安装界面，如图所示： 7、到此页面之后，等待自动检测安装，如图所示： 8、等到出现如图所示页面后点击“skip”按钮，跳过检测，直接进入安装设置界面，如图所示： 9、安装设计界面如图所示： 10、点击Next按钮进入设置语言界面，设置语言为“简体中文”，如图所示： 11、点击Nest按钮进入系统键盘设置按钮，设置系统键盘为“美国英语式”，如图所示： 12、点击下一步按钮，弹出“安装号码”对话框，选择跳 本科实验报告 课程名称：操作系统 学号： 姓名： 专业： 班级： 指导教师： 课内实验目录及成绩 信息技术学院 实验(实验一) 1 实验名称：基本shell命令及用户管理 2 实验目的 2.1 掌握安装Linux操作系统的方法。 2.2 掌握Linux操作系统的基本配置。 2.3 了解GNOME桌面环境。 2.4 掌握基本shell命令的使用。 3 实验准备 3.1 下载VMware Workstation虚拟机软件（版本不限）。 3.2 准备Linux操作系统的安装源（内核版本和发行版本均不限）。 注：实验准备、实验内容4.1和4.2作为回家作业布置，同学们利用课余时间可在私人计算机上完成。 4 实验要求、步骤及结果 4.1 安装虚拟机软件。 【操作要求】安装VMware Workstation虚拟机软件，并填写以下4.1.1和4.1.2的内容。 4.1.1【VMware Workstation虚拟机版本号】 4.1.2【主要配置参数】 4.2 安装Linux操作系统。 【操作要求】安装Linux操作系统，版本不限。 Linux发行版本： Linux内核版本： 【主要操作步骤：包括分区情况】 1、创建一台虚拟机安装操作系统时客户机操作系统选择Linux 2、修改虚拟机的安装路径。 3、建一个新的虚拟磁盘，磁盘的空间20GB，并且将单个文件存储虚拟磁盘。 4、设置分区完毕，安装虚拟机 4.3 了解Linux操作系统的桌面环境之一GNOME。 【操作要求】查看桌面图标，查看主菜单，查看个人用户主目录等个人使用环境。【操作步骤1】桌面图标 【操作步骤2】主菜单 【操作步骤3】个人用户主目录 【操作步骤4】启动字符终端 实验五：管道通信 实验内容: 1.阅读以下程序： #include 2.阅读以下程序： #include 实验二进程调度 1．目的和要求 通过这次实验，理解进程调度的过程，进一步掌握进程状态的转变、进程调度的策略，进一步体会多道程序并发执行的特点，并分析具体的调度算法的特点，掌握对系统性能的评价方法。 2．实验内容 阅读教材《计算机操作系统》第二章和第三章，掌握进程管理及调度相关概念和原理。 编写程序模拟实现进程的轮转法调度过程，模拟程序只对PCB进行相应的调度模拟操作，不需要实际程序。假设初始状态为：有 n 个进程处于就绪状态，有m个进程处于阻塞状态。采用轮转法进程调度算法进行调度（调度过程中，假设处于执行状态的进程不会阻塞），且每过 t 个时间片系统释放资源，唤醒处于阻塞队列队首的进程。 程序要求如下： 1）输出系统中进程的调度次序； 2）计算CPU利用率。 3．实验环境 Windows操作系统、VC++6.0 C语言 4 设计思想： (1)程序中进程可用PCB表示，其类型描述如下： struct PCB_type { int pid ;// 进程名 int state ;// 进程状态 2——表示“执行”状态 1——表示“就绪”状态 0——表示“阻塞”状态 int cpu_time ; //运行需要的CPU寸间(需运行的时间片 个数) } 用PCB来模拟进程； (2)设置两个队 列，将处于“就绪”状态的进程PCB挂在队列readyxx ;将处于“阻塞”状态的进程 PCB挂在队列blockedxx。 队列类型描述如下： struct QueueNode{ struct PCB_type PCB; Struct QueueNode *next; } 并设全程量： struct QueueNode *ready_head=NULL,//ready 队列队首指针 *ready_tail=NULL , //ready 队列队尾指针 *blocked_head=NULL,//blocked 队列队首指 针 *blocked_tail=NULL; //blocked 队列队尾指 针 (3)设计子程序： start_state(); 读入假设的数据，设置系统初始状态，即初始化就绪队列和 阻塞队列 dispath(); 模拟调度，当就绪队列的队首进程运行一个时间片后，放到就绪队列末尾，每次都是队首进程进行调度，一个进程运行结束 就从就绪队列中删除，当到 t 个时间片后，唤醒阻塞队列队首进程。 实验五线程的同步 1、实验目的 （1）进一步掌握Windows系统环境下线程的创建与撤销。 （2）熟悉Windows系统提供的线程同步API。 （3）使用Windows系统提供的线程同步API解决实际问题。 2、实验准备知识：相关API函数介绍 ①等待对象 等待对象（wait functions）函数包括等待一个对象（WaitForSingleObject （））和等待多个对象（WaitForMultipleObject（））两个API函数。 1）等待一个对象 WaitForSingleObject（）用于等待一个对象。它等待的对象可以为以下对象 之一。 ·Change ontification:变化通知。 ·Console input: 控制台输入。 ·Event:事件。 ·Job:作业。 ·Mutex:互斥信号量。 ·Process:进程。 ·Semaphore:计数信号量。 ·Thread:线程。 ·Waitable timer:定时器。 原型： DWORD WaitForSingleObject( HANDLE hHandle, // 对象句柄 DWORD dwMilliseconds // 等待时间 ）； 参数说明： （1）hHandle:等待对象的对象句柄。该对象句柄必须为SYNCHRONIZE访问。 （2）dwMilliseconds:等待时间，单位为ms。若该值为0，函数在测试对象的状态后立即返回，若为INFINITE，函数一直等待下去，直到接收到 一个信号将其唤醒，如表2-1所示。 返回值： 如果成功返回，其返回值说明是何种事件导致函数返回。 Static HANDLE hHandlel = NULL; DWORD dRes; dRes = WaitForSingleObject(hHandlel,10); //等待对象的句柄为hHandlel，等待时间为10ms 2）等待对个对象 WaitForMultiple（）bject（）在指定时间内等待多个对象，它等待的对象与 WaitForSingleObject（）相同。 原型： DWORD WaitForMultipleObjects（ DWORD nCount， //句柄数组中的句柄数 CONST HANDLE * lpHandles， //指向对象句柄数组的指针 BOOL fWaitAll， //等待类型 DWORD dwMilliseconds //等待时间 ）； 参数说明： （1）nCount：由指针 * lpHandles指定的句柄数组中的句柄数，最大数是MAXIMUM WAIT OBJECTS。 （2）* lpHandles：指向对象句柄数组的指针。 （3）fWaitAll：等待类型。若为TRUE，当由lpHandles数组指定的所有对象被唤醒时函数返回；若为FALSE，当由lpHandles数组指定的某一个 对象被唤醒时函数返回，且由返回值说明是由于哪个对象引起的函数 返回。 （4）dwMilliseconds：等待时间，单位为ms。若该值为0，函数测试对象的状态后立即返回；若为INFINITE，函数一直等待下去，直到接收到 一个信号将其唤醒。 返回值：、 如果成功返回，其返回值说明是何种事件导致函数返回。 各参数的描述如表2-2所示。操作系统实验三
操作系统课程设计答案
操作系统实验实验1
操作系统原理-进程调度实验报告
操作系统实验报告一
操作系统原理实验-系统内存使用统计5
操作系统实验之内存管理实验报告
上海大学操作系统(二)实验报告(全)
计算机操作系统实验四
操作系统实验报告
操作系统实验3答案
操作系统原理实验四
操作系统实验四
操作系统实验报告4
操作系统实验报告
操作系统实验一
操作系统实验报告_实验五
操作系统实验报告
操作系统原理实验五