操作系统实验全(包含源代码)
操作系统试验指导
—. 课程的性质、目的和任务
操作系统在整个计算机系统软件中占有中心地位。其作用是对计算机系统进行统一的调度和管理，提供各种强有力的系统服务，为用户创造既灵活又方便的使用环境。本课程是计算机及应用专业的一门专业主干课和必修课。通过本课程的学习,使学生掌握操作系统的基本概念、设计原理及实施技术,具有分析操作系统和设计、实现、开发实际操作系统的能力。
二. 实验的意义和目的
操作系统是计算机专业学生的一门重要的专业课程。操作系统质量对整个计算机系统的性能和用户对计算机的使用有重大的影响。一个优良的操作系统能极大地扩充计算机系统的功能，充分发挥系统中各种设备的使用效率，提高系统工作的可靠性。由于操作系统涉及计算机系统中各种软硬件资源的管理，内容比较繁琐，具有很强的实践性。要学好这门课程，必须把理论与实践紧密结合，才能取得较好的学习效果。培养计算机专业的学生的系统程序设计能力，是操作系统课程的一个非常重要的环节。通过操作系统上机实验，可以培养学生程序设计的方法和技巧，提高学生编制清晰、合理、可读性好的系统程序的能力，加深对操作系统课程的理解。使学生更好地掌握操作系统的基本概念、基本原理、及基本功能,具有分析实际操作系统、设计、构造和开发现代操作系统的基本能力。
三.实验运行环境及上机前的准备
实验运行环境: 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; /*结构体pcb的指针类型*/
}*ready=NULL,*p;/*指向当前用行的pcb*/
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(); } #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; /*结构体pcb的指针类型*/ }*ready=NULL,*p;/*指向当前用行的pcb*/ typedef struct pcb PCB; void 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; } } void 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 实验四、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; linux源代码分析:Linux操作系统源代码详细分析 疯狂代码 https://www.wendangku.net/doc/951015000.html,/ ?:http:/https://www.wendangku.net/doc/951015000.html,/Linux/Article28378.html 内容介绍: Linux 拥有现代操作系统所有功能如真正抢先式多任务处理、支持多用户内存保护虚拟内存支持SMP、UP符合POSIX标准联网、图形用户接口和桌面环境具有快速性、稳定性等特点本书通过分析Linux内核源代码充分揭示了Linux作为操作系统内核是如何完成保证系统正常运行、协调多个并发进程、管理内存等工作现实中能让人自由获取系统源代码并不多通过本书学习将大大有助于读者编写自己新 第部分 Linux 内核源代码 arch/i386/kernel/entry.S 2 arch/i386/kernel/init_task.c 8 arch/i386/kernel/irq.c 8 arch/i386/kernel/irq.h 19 arch/i386/kernel/process.c 22 arch/i386/kernel/signal.c 30 arch/i386/kernel/smp.c 38 arch/i386/kernel/time.c 58 arch/i386/kernel/traps.c 65 arch/i386/lib/delay.c 73 arch/i386/mm/fault.c 74 arch/i386/mm/init.c 76 fs/binfmt-elf.c 82 fs/binfmt_java.c 96 fs/exec.c 98 /asm-generic/smplock.h 107 /asm-i386/atomic.h 108 /asm- i386/current.h 109 /asm-i386/dma.h 109 /asm-i386/elf.h 113 /asm-i386/hardirq.h 114 /asm- i386/page.h 114 /asm-i386/pgtable.h 115 /asm-i386/ptrace.h 122 /asm-i386/semaphore.h 123 /asm-i386/shmparam.h 124 /asm-i386/sigcontext.h 125 /asm-i386/siginfo.h 125 /asm-i386/signal.h 127 /asm-i386/smp.h 130 /asm-i386/softirq.h 132 /asm-i386/spinlock.h 133 /asm-i386/system.h 137 /asm-i386/uaccess.h 139 //binfmts.h 146 //capability.h 147 /linux/elf.h 150 /linux/elfcore.h 156 /linux/errupt.h 157 /linux/kernel.h 158 /linux/kernel_stat.h 159 /linux/limits.h 160 /linux/mm.h 160 /linux/module.h 164 /linux/msg.h 168 /linux/personality.h 169 /linux/reboot.h 169 /linux/resource.h 170 /linux/sched.h 171 /linux/sem.h 179 /linux/shm.h 180 /linux/signal.h 181 /linux/slab.h 184 /linux/smp.h 184 /linux/smp_lock.h 185 /linux/swap.h 185 /linux/swapctl.h 187 /linux/sysctl.h 188 /linux/tasks.h 194 /linux/time.h 194 /linux/timer.h 195 /linux/times.h 196 /linux/tqueue.h 196 /linux/wait.h 198 init/.c 198 init/version.c 212 ipc/msg.c 213 ipc/sem.c 218 ipc/shm.c 227 ipc/util.c 236 kernel/capability.c 237 kernel/dma.c 240 kernel/exec_do.c 241 kernel/exit.c 242 kernel/fork.c 248 kernel/info.c 255 kernel/itimer.c 255 kernel/kmod.c 257 kernel/module.c 259 kernel/panic.c 270 kernel/prk.c 271 kernel/sched.c 275 kernel/signal.c 295 kernel/softirq.c 307 kernel/sys.c 307 kernel/sysctl.c 318 kernel/time.c 330 mm/memory.c 335 mm/mlock.c 345 mm/mmap.c 348 mm/mprotect.c 358 mm/mremap.c 361 mm/page_alloc.c 363 mm/page_io.c 368 mm/slab.c 372 mm/swap.c 394 mm/swap_state.c 395 mm/swapfile.c 398 mm/vmalloc.c 406 mm/vmscan.c 409 操作系统实验报告 集团企业公司编码：（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队列队尾指 针 计算机操作系统实验报告 实验内容： 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函数中使用循环依 实验室质量手册和程序文件的编写 李正东（原中国计量科学研究院教授）编 1质量管理的原则 1.1 以顾客为关注焦点 1.1.1 概述 质量管理的主要关注点是满足顾客要求并且努力超越顾客期望。 1.1.2 理论依据 组织只有赢得和保持顾客和其他有关的相关方的信任才能获得持续成功。 1.2 领导作用 1.2.1 概述 各级领导建立统一的宗旨和方向，创造全员积极参与的条件，实现组织的质量目标。1.2.2 理论依据 统一的宗旨和方向的建立，以及全员的积极参与，能够使组织将战略、方针、过程和资源保持一致，以实现其目标。 1.3 全员参与 1.3.1 概述 在整个组织内各级人员的胜任、被授权和积极参与，是提高组织创造和提供价值能力的必要条件。 1.3.2 理论依据 为了有效和高效的管理组织，各级人员得到尊重并参与其中是极其重要的。通过表彰、授权和提高能力，促进在实现组织的质量目标过程中的全员积极参与。 1.4 过程方法 1.4.1 概述 将活动作为相互关联、功能连贯的过程系统来理解和管理时，可更加有效和高效的得到一致的、可预知的结果。 1.4.2 理论依据 质量管理体系是由相互关联的过程所组成。理解体系是如何产生结果的，能够使组织尽可能地完善其体系和绩效。 1.5 改进 1.5.1 概述 成功的组织持续关注改进。 1.5.2 理论依据 改进对于组织保持当前的绩效水平，对其内、外部条件的变化做出反应并创造新的机会都是非常必要的。 1.6 循证决策 1.6.1 概述 基于数据和信息的分析和评价的决策，更有可能产生期望的结果。 1.6.2 理论依据 决策是一个复杂的过程，并且总是包含一些不确定因素。它经常涉及多种类型和来源的输入及其解释，而这些解释可能是主观的。重要的是理解因果关系和可能的非预期后果。对事实、证据和数据的分析可导致决策更加客观、可信。 1.7 关系管理 Linux操作系统源代码详细分析 容简介： Linux 拥有现代操作系统所有的功能，如真正的抢先式多任务处理、支持多用户，存保护，虚拟存，支持SMP、UP，符合POSIX标准，联网、图形用户接口和桌面环境。具有快速性、稳定性等特点。本书通过分析Linux的核源代码，充分揭示了Linux作为操作系统的核是如何完成保证系统正常运行、协调多个并发进程、管理存等工作的。现实中，能让人自由获取的系统源代码并不多，通过本书的学习，将大大有助于读者编写自己的新程序。 第一部分 Linux 核源代码 arch/i386/kernel/entry.S 2 arch/i386/kernel/init_task.c 8 arch/i386/kernel/irq.c 8 arch/i386/kernel/irq.h 19 arch/i386/kernel/process.c 22 arch/i386/kernel/signal.c 30 arch/i386/kernel/smp.c 38 arch/i386/kernel/time.c 58 arch/i386/kernel/traps.c 65 arch/i386/lib/delay.c 73 arch/i386/mm/fault.c 74 arch/i386/mm/init.c 76 fs/binfmt-elf.c 82 fs/binfmt_java.c 96 fs/exec.c 98 include/asm-generic/smplock.h 107 include/asm-i386/atomic.h 108 include/asm-i386/current.h 109 include/asm-i386/dma.h 109 include/asm-i386/elf.h 113 include/asm-i386/hardirq.h 114 include/asm-i386/page.h 114 include/asm-i386/pgtable.h 115 include/asm-i386/ptrace.h 122 include/asm-i386/semaphore.h 123 include/asm-i386/shmparam.h 124 include/asm-i386/sigcontext.h 125 include/asm-i386/siginfo.h 125 include/asm-i386/signal.h 127 include/asm-i386/smp.h 130 include/asm-i386/softirq.h 132 include/asm-i386/spinlock.h 133 include/asm-i386/system.h 137 include/asm-i386/uaccess.h 139 华东交通大学 软件学院 操作系统实验报告 专业: 计算机科学与技术 姓名: 林庆达 学号: 3103005138 2005-6 试验一进程调度 一、实验目的: 编写和调试一个进程调度程序，以加深对进程的概念及进程调度算法的理解。 二、实验内容：以两种典型算法为例说明实现的算法 (一)、最高优先数优先的调度算法 1、实验原理 进程调度算法：采用最高优先数优先 的调度算法（即把处理机分配给优先数最 高的进程）和先来先服务算法。 每个进程有一个进程控制块（PCB） 表示。进程控制块可以包含如下信息：进 程名、优先数、到达时间、需要运行时间、 已用CPU时间、进程状态等等。 进程的优先数及需要的运行时间可以 事先人为地指定（也可以由随机数产生）。 进程的到达时间为进程输入的时间。 进程的运行时间以时间片为单位进 行计算。 每个进程的状态可以是就绪W （Wait）、运行R（Run）、或完成F（Finish） 三种状态之一。 就绪进程获得CPU后都只能运行一 个时间片。用已占用CPU时间加1来表示。 如果运行一个时间片后，进程的已占 用CPU时间已达到所需要的运行时间， 则撤消该进程，如果运行一个时间片后进 程的已占用CPU时间还未达所需要的运 行时间，也就是进程还需要继续运行，此 时应将进程的优先数减1（即降低一级）， 然后把它插入就绪队列等待CPU。 每进行一次调度程序都打印一次运 行进程、就绪队列、以及各个进程的PCB， 以便进行检查。 重复以上过程，直到所有进程都完成为止。 2、源代码： #include "stdio.h" #include 操作系统－实验三 文件系统的用户界面 一、实验目的 进一步理解、使用和掌握文件的系统调用、文件的标准子例程，能利用和选择这些基本的文件操作完成复杂的文件处理工作。 二、实验题目 1．编写一个文件复制的C语言程序：分别使用文件的系统调用read(fd, buf, nbytes), write(fd, buf, nbytes)和文件的库函数fread(buf, size, nitems, fp), fwrite(buf, size, nitems, fp)，编写一个文件的复制程序(文件大小>1M )，文件可以编一个C 程序来生成，或使用/usr/bin下的二进制执行文件。 调用格式例如： copy file1 file2 #include 上述函数中nbytes, size和nitems都取值为1时（即一次读写一个字节），比较系统调用和流文件两种程序的执行效率。当nbytes取4096字节，size取1字节且nitems取4096时（即一次读写4096字节），再次比较这两种程序的执行效率(文件大小>1M)。如： 创建大文件的方法之一，比如用creat 创建一个新文件，用open写打开该文件，用lseek将写指针移到很远处，写入随便一个字符。比如移动0x100000，用write写个“1”，就会得到一个1M大小的文件。也可到Linux的/usr/bin找一个1～3M左右的大的执行文件。 对于单独使用的速度较快的计算机，文件要10M～100M。 2．编写一个父子进程之间用无名管道进行数据传送的C程序。父进程逐一读出一个文件的内容，并通过管道发送给子进程。子进程从管道中读出信息，再将其写入一个新的文件。程序结束后，对原文件和新文件的内容进行比较。 3．在两个用户的独立程序之间，使用有名管道，重新编写一个C程序，实现题2的功能。 三、源代码 1．编写一个文件复制的C语言程序：分别使用文件的系统调用read(fd, buf, nbytes), write(fd, buf, nbytes)和文件的库函数fread(buf, size, nitems, fp), fwrite(buf, size, nitems, fp)，编写一个文件的复制程序。 程序一 #define BUFSIZE 4096 #include 实验室管理程序 1目的 为了确保实验室具备所从事检测和校准活动的能力，健全实验室管理，以提供及时、准确、公正、严谨的服务，特制定本程序。 2范围 本程序适用于产品（性能）实验室、精密检测实验室、校准、理化实验室的范围、程序、人员要求、过程控制及外委过程的确定。 3术语 3.1实验室：检验、检测和校准的设施，可包括但不限于化学、冶金、尺寸、物理、电子或可靠性的测试。 3.2检验：通过观察和判断，适当时结合测量、试验所进行的符合性评价。 3.3检测：按照规定的程序，为确定给定的产品、材料、设备、生物组织、物理现象、工艺或服务的一种或多种特性的技术操作。 3.4校准：在规定条件下，为确立计量仪器或计量系统的示值或实物量具所代表的值与相对应的被计量的已知值之间关系的一组操作。 3.5实验室范围：包括以下内容的受控文件： ?实验室有资格开展的具体测试、评估和校验 ?开展上述活动的所需的设备清单 ?开展上述活动的方法和标准清单 3.6实验室认可：权威机构给予某实验室具有执行规定任务能力的正式承认。3.7非标准试验：指国际标准、国家标准、行业标准、地方标准中没有规定的试验方法。主要是指本企业自己确定的试验方法。 4职责 4.1产品工程处为本程序主管部门，负责产品（性能）试验室的管理。 4.2质量保证处计量检测中心负责产品检测及校准和理化实验室的管理。 4.3铸造分厂负责本单位实验室的管理。 4.4人力资源处负责实验室试验、检验人员的培训、建档工作。 5内容 5.1工作流程 责任部门 管理策划处 工业工程组 各实验室 人力资源处各实验室各实验室 各实验室 各实验室 实验室 各实验室 各实验室 各实验室 各实验室发展规划处各实验室采购供应处各实验室0 1 02 03 04 05 06 07 08 09 10 1 1 12 13 流程图输出文件 实验室编制和岗位描述，组 织机构图 质量方针 人员名单和技术档案 试验项目清单 标准设备清单，标准清单，标准物 质清单 试验标准清单 文件记录目录借阅记录 非标准试验规程确认记录 测量不确定度分析报告 试验设施环境的需求报告，实验 室环境监试测 检测设备采购立项申请 设备档案，维护计划，维护记录 使用维护说明书 ##include 操作系统实验报告 实验名称: 系统的引导 所在班级: 指导老师: 老师 实验日期: 2014年3 月29 日 一、实验目的 ◆熟悉hit-oslab实验环境； ◆建立对操作系统引导过程的深入认识； ◆掌握操作系统的基本开发过程； ◆能对操作系统代码进行简单的控制，揭开操作系统的神秘面纱。 二、实验容 1. 阅读《Linux核完全注释》的第6章引导启动程序，对计算机和Linux 0.11的引导过程进行初步的了解。 2. 按照下面的要求改写0.11的引导程序bootsect.s。 3. 有兴趣同学可以做做进入保护模式前的设置程序setup.s。 4. 修改build.c，以便可以使用make BootImage命令 5. 改写bootsect.s主要完成如下功能： bootsect.s能在屏幕上打印一段提示信息XXX is booting...，其中XXX是你给自己的操作系统起的名字，例如LZJos、Sunix等。 6. 改写setup.s主要完成如下功能： bootsect.s能完成setup.s的载入，并跳转到setup.s开始地址执行。而setup.s 向屏幕输出一行"Now we are in SETUP"。setup.s能获取至少一个基本的硬件参数（如存参数、显卡参数、硬盘参数等），将其存放在存的特定地址，并输出到屏幕上。setup.s不再加载Linux核，保持上述信息显示在屏幕上即可。 三、实验环境 本实验使用的系统是windows系统或者是Linux系统，需要的材料是osexp。 四、实验步骤 1. 修改bootsect.s中的提示信息及相关代码; 到osexp\Linux-0.11\boot目录下会看到图1所示的三个文件夹，使用UtraEdit 打开该文件。将文档中的98行的mov cx,#24修改为mov cx,#80。同时修改文档中的第246行为图2所示的情形。 图1图2 图3 2. 在目录linux-0.11\boot下,分别用命令as86 -0 -a -o bootsect.obootsect.s和 ld86 -0 -s -obootsectbootsect.o编译和bootsect.s，生成bootsect文件; 在\osexp目录下点击MinGW32.bat依此输入下面的命令： cd linux-0.11 cd boot as86 -0 -a -o bootsect.obootsect.s ld86 -0 -s -o bootsectbootsect.o 课程实验报告 课程名称姓名实验名称实验目的及要求 实验3进程并发与同步 1、加深对进程概念的理解，区分进程并发执行与串行执行； 2、掌握进程并发执行的原理，理解进程并发执行的特点； 3、了解fork()系统调用的返回值，掌握用fork()创建进程的方法；熟悉wait、exit等系统调用； 4、能利用相应的系统调用实现进程树与进程间的同 步。 实 验操作系统：linux Un bu ntu 11.10 环 境实验工具：Vmware 实验内容 1、编写一C语言程序，实现在程序运行时通过系统调用fork()创建两个子进程，使父、子三进程并发执行，父亲进程执行时屏幕显示“I am father ”，儿子进 程执行时屏幕显示“ I am son "，女儿进程执行时屏幕显示“ I am daughter ”。 要求多次连续反复运行这个程序，观察屏幕显示结果的顺序，直至出现不一样的情况为止。要求有运行结果截图与结果分析 2、连续4个fork()的进程家族树，family1-1.c 程序清单如下： #in clude 3、 修改程序1,在父、子进程中分别使用 wait 、exit 等系统调用“实现”其同 步推进，父进程必须等待儿子进程与女儿进程结束， 才可以输出消息。 写出相应的同 步控制，并分析运行结果。 4、 创建一个子进程，并给它加载程序，其功能是调用键盘命令“ ls -I ”，已知 该键盘命令的路径与文件名为： /bin/ls 。父进程创建子进程， 并加载./child2 程序。 写出相应的程序代码并分析程序运行结果。 1、编写一 C 语言程序，实现在程序运行时通过系统调用 fork()创建两个子进 程，使父、子三进程并发执行，父亲进程执行时屏幕显示“ I am father ”， 儿子进程执行时屏幕显示“ I am son ”，女儿进程执行时屏幕显示“ I am daughter "。并且反复的测试，观察每一次的执行的顺序有什么不同 2、修改程序1,在父、子进程中分别使用 wait 、exit 等系统调用“实现”其同 步推进，父进程必须等待儿子进程与女儿进程结束，才可以输出消息。 4、创建一个子进程，并给它加载程序，其功能是调用键盘命令“ ls -I ”，已知 该键盘命令的路径与文件名为： /bin/ls 。父进程创建子进程， 并加载./child2 程序。 法 描 述 及 实 验 步 骤 调 试过 程及实 验结果 第1部分操作系统概论名词解释 脱机输入／输出 具体的输入／输出不需要在主计算机上进行的方式也称“脱机输入／输出” 批处理 作业是由操作系统成批地进行处理，操作系统能自动地从输入池读入下一个作业，并予以运行和输出，如此直到整批作业全部处理完毕。 SPOOLING 由操作系统将磁盘模拟为输入／输出设备的处理方式称为SPOOLING（Simultaneous Periph eral Operating On Line），即“并行的外部设备操作联机”，也称“假脱机”。SPOOLING系统是以磁盘为几乎无限巨大的缓冲区来解决低速的I/O设备与高速的CPU之间的速度匹配问题。 分时系统 为了降低交互式系统的等待时间和运行时间的比率，系统通过多台终端同时向很多用户提供运行环境，这种分时系统就能以合理的成本向用户提供交互式使用计算机的方便。 多路性 一台主机可连接多台终端，多个终端用户可以同时使用计算机，共享系统的硬软件资源。 交互性 用户能与系统进行对话。在一个多步骤作业的运行过程中，用户能通过键盘等设备输入数据或命令，系统获得用户的输入后做出响应，显示执行的状况或结果。 实时操作系统 是一种能在限定的时间内对输入进行快速处理并做出响应的计算机处理系统 多处理机系统 一个计算机系统中可具有多个CPU或处理机。一般用微处理器构成阵列系统，其运算速度可以达到上万亿次， 分布式操作系统 分布式系统是一种多计算机系统，这些计算机可以处于不同的地理位置和拥有不同的软硬件资源，并用通信线路连接起来，具有独立执行任务的能力。分布式系统具有一个统一的操作系统，它可以把一个大任务划分成很多可以并行执行的子任务，并按一定的调度策略将它们动态地分配给各个计算机执行，并控制管理各个计算机的资源分配、运行及计算机之间的通信，以协调任务的并行执行。以上所有的管理工作对用户都是透明的。 网络操作系统 计算机网络是指用数据通信系统把分散在不同地方的计算机群和各种计算机设备连接起来的集合，它主要用于数据通信和资源共享，特别是软件和信息共享。 操作系统实验报告 学生学院计算机学院 专业班级计算机科学与技术3班学号3213005910 学生姓名林虹 指导教师丁国芳 2015 年12月15 日 目录 1 实验一进程调度 (1) 2 实验二银行家算法 (16) 3 实验三动态分区分配方式的模拟 (20) 4 实验四仿真各种磁盘调度算法 (26) 实验一进程调度 1. 实验目的 编写并调试一个模拟的进程调度程序，分别采用“短进程优先”、“时间片轮转”、“高响应比优先”调度算法对随机产生的五个进程进行调度，并比较算法的平均周转时间。以加深对进程的概念及进程调度算法的理解。 2. 实验要求 1.每个进程由一个进程控制块（PCB）表示，进程控制块可以包含如下信息：进程 名、优先数（响应比）、到达时间、需要运行时间（进程的长度）、已运行时间、进 程状态等等（可以根据需要自己设定）。 2.由程序自动生成进程（包括需要的数据，要注意数据的合理范围），第一个进程到 达时间从0开始，其余进程到达时间随机产生。 3.采用时间片轮转调度算法时，进程的运行时间以时间片为单位进行计算。 4.每个进程的状态可以是就绪W（Wait）、运行R（Run）、或完成F（Finish）三种 状态之一。 5.每进行一次调度，程序都要输出一次运行结果：正在运行的进程、就绪队列中的进 程、完成的进程以及各个进程的PCB，以便进行检查。 6.最后计算各调度算法的平均周转时间，并进行比较、分析。 3. 实验内容 a.算法原理 （1）短进程优先调度算法 “短进程优先”调度算法的基本思想是把CPU分配给就绪队列中需要时间最短的进程。 （2）时间片轮转算法 将系统中所有的就绪进程按照FCFS原则，排成一个队列。每次调度时将CPU 分派给队首进程，让其执行一个时间片。时间片的长度从几个ms到几百ms。在一个时间片结束时，发生时钟中断。调度程序据此暂停当前进程的执行，将其送到就绪队列的末尾，并通过上下文切换执行当前的队首进程。进程可以未使用完一个时间片，就出让CPU。 （3）高响应比优先算法 HRRN调度策略同时考虑每个作业的等待时间长短和估计需要的执行时间长短，从中选出响应比最高的作业投入执行。 每个作业完成后要打印该作业的开始运行时刻、完成时刻、周转时间和带权周转时间，这一组作业完成后要计算并打印这组作业的平均周转时间、带权平均周转时间。 广州大学学生实验报告 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、内存储器、外存储器、各种各样的输入输出设备，通常称为硬件资源；它可能有多个用户同时运行他们各自的程序，共享着大量数据，通常称为软件资源。如果没有一个对这些资源进行统一管理的软件，计算机不可能协调一致、高效率地完成用户交给它的任务。 从资源管理的角度，操作系统是为了合理、方便地利用计算机系统，而对其硬件资源和软件资源进行管理的软件。它是系统软件中最基本的一种软件，也是每个使用计算机的人员必须学会使用的一种软件。 4．3．1 操作系统功能 操作系统五大管理功能，即作业管理、存储管理、信息管理、设备管理和处理机管理。这些管理工作是由一套规模庞大复杂的程序来完成的。 作业管理解决的是允许谁来使用计算机和怎样使用计算机的问题。在操作系统中，把用户请求计算机完成一项完整的工作任务称为一个作业。当有多个用户同时要求使用计算机时，允许哪些作业进入，不允许哪些进入，对于已经进入的作业应当怎样安排它的执行顺序，这些都是作业管理的任务。 存储管理解决的是内存的分配、保护和扩充的问题。计算机要运行程序就必须要有一定的内存空间。当多个程序都在运行时，如何分配内存空间才能最大限度地利用有限的内存空间为多个程序服务；当内存不够用时，如何利用外存将暂时用不到的程序和数据“滚出”到外存上去，而将急需使用的程序和数据“滚入”到内存中来，这些都是存储管理所要解决的问题。 信息管理解决的是如何管理好存储在磁盘、磁带等外存上的数据。由于计算机处理的信息量很大而内存十分有限，绝大部分数据都是保存在外存上。如果要用户自己去管理就要了解如何将数据存放到外存的物理细节，编写大量程序。在多个用户使用同一台计算机的情况下既要保证各个用户的信息在外存上存放的位置不会发生冲突，又要防止对外存空间占而不用；既要保证任一用户的信息不会被其他用户窃取、破坏，又要允许在一定条件下多个用户共享，这些都是要靠信息管理解决的。信息管理有时也称为文件管理，是因为在操作系统中通常是以“文件”作为管理的单位。操作系统中的文件概念与日常生活中的文件不同，在操作系统中，文件是存储在外存上的信息的集合，它可以是源程序、目标程序、一组命令、图形、图像或其它数据。 设备管理主要是对计算机系统中的输入输出等各种设备的分配、回收、调度和控制，以及输入输出等操作。 处理机管理主要解决的是如何将CPU分配给各个程序，使各个程序都能够得到合理的运行安排。 从资源管理的角度来看，可以把操作系统看作是控制和管理计算机资源的一组程序；从用户的角度看，操作系统是用户和计算机之间的界面。用户看到的是操作系统向用户提供的一组操作命令，用户可以通过这些命令来使用和操作计算机。因而学会正确使用这些命令就成为学会使用计算机的第一步。 4．3．2 操作系统基本类型 计算机上使用的操作系统种类很多，但其基本类型可以划分为三类，即批处理操作系统、分时操作系统和实时操作系统。 批处理操作系统的设计目标是为了最大限度地发挥计算机资源的效率；在这种操作系统环境下，用户要把程序、数据和作业说明一次提交给系统操作员，输入计算机，在处理过程中与外部不再交互。分时操作系统的设计目标是使多个用户可以通过各自的终端互不干扰地同时使用同一台计算机交互进行操作，就好像他自己独占了该台计算机一样。实时操作系统则要 操作系统实验报告 银行家算法 班级：计算机()班 姓名：李君益 学号：(号) 提交日期： 指导老师: 林穗 一、设计题目 加深了解有关资源申请、避免死锁等概念，并体会和了解死锁和避免死锁的具体实施方法。 要求编写和调试一个系统动态分配资源的简单模拟程序，观察死锁产生的条件，并采用银行家算法，有效的防止和避免死锁的发生。 二、设计要求 内容： 编制银行家算法通用程序，并检测思考题中所给状态的安全性。 要求： (1)下列状态是否安全？(三个进程共享个同类资源) 进程已分配资源数最大需求数 (状态) (状态) (2)考虑下列系统状态 分配矩阵最大需求矩阵可用资源矩阵 问系统是否安全？若安全就给出所有的安全序列。若进程请求()，可否立即分配？ 三、设计分析 一．关于操作系统的死锁 ．死锁的产生 计算机系统中有许多独占资源，他们在任一时刻只能被一个进程使用，如磁带机，绘图仪等独占型外围设备，或进程表，临界区等软件资源。两个进程同时向一台打印机输出将导致一片混乱，两个进程同时进入临界区将导致数据库错误乃至程序崩溃。正因为这些原因，所有操作系统都具有授权一个进程独立访问某一辞源的能力。一个进程需要使用独占型资源必须通过以下的次序： ●申请资源 ●使用资源 ●归还资源 若申请施资源不可用，则申请进程进入等待状态。对于不同的独占资源，进程等待的方式是有差别的，如申请打印机资源、临界区资源时，申请失败将一位这阻塞申请进程；而申请打开文件文件资源时，申请失败将返回一个错误码，由申请进程等待一段时间之后重试。只得指出的是，不同的操作系统对于同一种资源采取的等待方式也是有差异的。 在许多应用中，一个进程需要独占访问多个资源，而操作系统允许多个进程并发执行共享系统资源时，此时可能会出现进程永远被阻塞的现象。这种现象称为“死锁”。 2.死锁的定义 一组进程处于死锁状态是指：如果在一个进程集合中的每个进程都在等待只能由该集合中的其他一个进程才能引发的时间，则称一组进程或系统此时发生了死锁。 ．死锁的防止 .死锁产生的条件： ●互斥条件 1.CPU的两种运行模式：内核态（又称核心态、系统态、管态）和用户态（又称目态）。 2.指令是控制计算机执行某种操作的命令。 3.特权指令：是一类具有特殊权限的指令，只用于操作系统或其他系统软件，普通用户不 能直接使用 4.非特权指令：也称为用户指令或普通指令，是普通用户能够直接使用的指令。这是指令 集中除特权指令外的所有指令。 5.操作系统的用户观点和系统观点:用户观点：为用户提供使用计算机系统的接口和各种 资源管理服务（从系统外部看）系统观点：管理和分配计算机系统硬件及软件资源。因此，操作系统是计算机资源的管理者（从系统内部看 6.操作系统：是控制和管理计算机系统内各种硬件和软件资源、有效地组织多道程序运行 的系统软件（或程序集合），是用户与计算机之间的接口。 功能：处理机管理、存储器管理、设备管理、文件管理、用户接口 7.多道程序设计的基本思想：在内存中同时存放多道程序，在管理程序的控制下交替 地执行。这些作业共享CPU和系统中的其他资源。 8.多道批处理系统优缺点：优点:系统资源利用率高；系统吞吐量大。缺点:用户作业等待 时间长；无交互性，用户一旦提交作业就失去了对其运行的控制能力 9.多道：系统在内存中存放多个作业，并且在外存上还保存大量的后备作业。 10.成批：系统按批次调度作业，而在系统运行过程中不允许用户和机器之间发生交互作用。 11.分时：对时间的共享。在分时系统中，分时主要是指若干并发程序对CPU时间的共享 12.Linux系统特点:与UNIX兼容；自由软件，源码公开；性能高，安全性强；便于定 制和再开发；互操作性高；全面的多任务和真正的32位操作系统 13.进程概念：程序在并发环境中的执行过程 进程最根本的属性：是动态性和并发性 进程的特征：动态性并发性独立性异步性 批处理系统的特征：脱机多道成批处理 分时系统的特征：多路性独立性及时性交互性 14.进程间的相互关系主要分为如下三种形式：1.互斥——竞争同一资源而发生相互制约2. 同步——协同完成一项任务 3. 通信——交换信息，合作完成一项工作 15.进程和程序的区别和联系：（1）进程是动态概念，程序是静态概念（2）进程有并发性， 程序没有（3）一个程序对应多个进程（4）进程有三个基本状态 进程的三种状态及其转换 16.进程控制块的作用：每个进程有唯一的进程控制块；操作系统根据PCB对进程实施控 制和管理；进程的动态、并发等特征是利用PCB表现出来的；PCB是进程存在的唯一标识 17.临界资源：一次仅允许一个进程访问的资源 18.临界区：简称CS区进程中访问临界资源的那段程序代码 19.原语是为完成某些特定的功能而编制的一段系统程序。原语操作也称做“原子操作”，即 一个操作中的所有动作要么全做，要么全不做。执行原语操作时，要屏蔽中断，以保证Linux操作系统源代码详细分析
操作系统实验报告
操作系统实验三
实验室质量手册和程序文件的编写
Linux操作系统源代码详细分析报告
操作系统实验指导_源码参考资料
操作系统-实验三
实验室管理程序
操作系统课程设计银行系统源代码
操作系统实验报告
操作系统实验报告三
计算机操作系统概论名词解释
操作系统实验报告
操作系统实验实验1
操作系统的概念和功能
操作系统实验报告
操作系统重点概念知识讲解