操作系统试验参考指导书.doc

《操作系统》

实 验 指 导 书

绍兴文理学院计算机系

前 言
1．实验总体目的
通过学生自己动手设计实验验证理论知识，使学生掌握操作系统特性和功能，掌握不同调度算法下进程调度、进程控制、进程调度与死锁，并必要掌握作业管理、存储器管理、设备管理和文献管理重要原理。加深对操作系统基本原理理解。
⒉ 合用专业
计算机科学与技术
⒊ 先修课程
C语言程序设计、计算机构成原理、数据构造
⒋ 实验学时分派
序号
实验名称
学时
实验规定
实验类型
1
分析操作系统所面临操作需求
2
必修
验证
2
进程管理
4
必修
设计
3
存储管理
4
必修
设计
4
设备管理
2
必修
设计
5
文献管理
4
必修
设计
⒌ 实验环境
有70台中档配备计算机构成小型局域网实验室环境。计算机详细规定：(1)Pentium 133Hz以上CPU；(2)建议至少256MB内存；(3)建议硬盘至少2GB，并有1GB空闲空间。(4)安装Windows操作系统及C语言编译程序或Linux虚拟环境。
⒍ 实验总体规定
培养计算机专业学生系统程序设计能力，是操作系统课程一种非常重要环节。通过操作系统上机实验，可以培养学生程序设计办法和技巧，提高学生编制清晰、合理、可读性好系统程序能力，加深对操作系统课程理解。使学生更好地掌握操作系统基本概念、基本原理、及基本功能，具备分析实际操作系统、设计、构造和开发当代操作系统基本能力。
实验规定做到：
1) 详细描述实验设计思想、程序构造及各模块设计思路；
2) 详细描述程序所用数据构造及算法；
3) 明确给出测试用例和实验成果；
4) 为增长程序可读性，在程序中进行恰当注释阐明；
5) 认真进行实验总结，涉及：设计中遇到问题、解决办法与收获等；
6) 实验报告撰写规定构造清晰、描述精确逻辑性强；
7) 实验过程中，同窗之间可以进行讨论互相提高，但绝对禁止抄袭。
⒎ 本实验重点、难点及教学办法建议
重点：理解进程调度中PCB设计，以实现对进程调度。
难点：进程调度程序设计，设备管理程序设计。
教学办法建议：力求在本指引书协助下，独立设计程序以加深理解。

实验一 分析操作系统所面临操作需求
（一）实验目
使学生理解操作系统所面临操作需求，掌握操作系统中进程管理、存储管理、设备管理和文献管理等功能。
（二）实验内容
1.  分析操作系统所面临操作需求；
2.  熟悉实验环境；
3.  资料收集与整顿，进行实验前期准备。
熟悉编程环境
 本课程中实验题目既可以在windows下用控制台应用程序实现，也可以在linux下用全屏幕程序实现。这里咱们一方面简介在windows下用vc++6.0设计控制台应用程序环节，然后简介在linux下用C语言编写全屏幕程序环节。
1. windows控制台应用程序 

图1-1 图1-2
图1-3
环节1：开机，单击“开始”按钮，选取“程序 ->Microsoft Visual Studio 6.0->Microsoft Visual C++6.0”进入Microsoft Visual C++6.0。见图1-1。
环节2：在Microsoft Visual C++6.0中，单击“File”菜单，选取“New”菜单命令，见图1-2。 
环节3：在“Files”选项卡中选取“C++ Source File”，见图1-3

2. linuxvi应用编程
登录 Linux是一种多顾客多任务操作系统，各种顾客可以拥有自己独立顾客账号
登录提示：
Red Hat Linux release 6.0 (Hedwing)
Kernel 2.2.5-15 on an i686
Login:
此时输入顾客户名（账号）并键入回车，则系统显示“passward”。在输入密码和回车。
登录后：[root@hawk/root]#
#表达是按root方式登录,$表达是普通顾客。Linux大小写敏感，用“-”加参数
zlinux:~# ls –F
HowTo/ HowToMin/ linux@ nag/ sag/
获取协助：Linux带有联机手册，可以用man命令来阅读
Zlinux:~$ man ls
虚拟终端 Linux可有各种顾客登录到同一种计算机，但普通微机只有一种终端难以体现。可以使用各种虚拟终端，用Alt+F1、Alt+F2等来切换。
退出系统 在停止使用系统时，要退出系统。详细办法：exit或logout，或Ctrl+D

关机 如果没有顾客在使用系统，可以关机。但是不能直接关闭电源，而要按正常顺序关机。普通顾客是不能关机，只有root顾客可以关机。
办法：可以使用halt或shutdown命令，也可以同步键入Ctrl+Alt+Del。

Windows 虚拟机环境：
登录到系统
点击桌面“VMware”图标——> Vmware Workstation窗口——>Commands——>Start this virtual machine
进入fedora后，顾客名：root
口 令：123456
使用编辑器vi 编辑文献
1. 进入linux文本模式之后，在命令行键入vi filename.c 然后回车。下面作某些简朴解释：一方面vi命令是打开vi编辑器。背面filename.c是顾客即将编辑c文献名字，注意扩展名字是.c；固然，vi编辑器功能很强，可以用它来编辑其他格式文献，例如汇编文献，其扩展名字是.s；也可以直接用vi打开一种新未命名文献，当保存时候再给它命名，只是这样做不很以便。
2. 最基本命令I ：当进入刚打开文献时，不能写入信息，这时按一下键盘上I键（insert），插入意思，就可以进入编辑模式了。如下图所示：

3. a与i是相似用法
4. 当文献编辑完后，需要保存退出，这时需要通过如下几种环节：1）按一下键盘上Esc 键；2）键入冒号(：)，紧跟在冒号背面是wq（意思是保存并退出）。如果不想保存退出，则在第二步键入冒号之后，键入！q（不带w，机尾部保存）。如下图所示：

5. 退出vi编辑器编辑模式之后，要对刚才编写程序进行编译。编译命令是：gcc filename.c [-o outputfilename]，其中gcc是c编译器。参数：filename.c 是刚才编辑c 文献（固然也可以是此前编写好c文献）；背面中括号里面参数是可选，它是一种输出文献。如果不选，默认输出文献是a.out ，选了之后输出文献就是outputfilename.out．
6. 最后一步是运营程序，办法如下：./outputfilename.out

实验二 进程管理
（一）实验目
掌握临界区概念及临界区设计原则；掌握信号量概念、PV操作含义以及应用PV操作实现进程同步与互斥；分析进程争用资源现象，学习解决进程互斥办法；掌握进程状态及状态转换；掌握惯用进程调度算法。
（二）实验内容
1．分析进程同步与互斥现象，编程实现典型进程同步问题——生产者消费者问题模仿；
2． 编写容许进程并行执行进程调度程序，在惯用进程（作业）调度算法：先来先服务算法、短作业优先算法、最高响应比优先算法、高优先权优先算法等调度算法中至少选取三种调度算法进行模仿，并输出平均周转时间和平均带权周转时间。
本实验涉及内容较多，可以在两个题目里选取一种完毕。
编程实现典型进程同步问题——生产者消费者问题模仿
模仿实现用同步机构避免发生进程执行时也许浮现与时间关于错误。
进程是程序在一种数据集合上运营过程，进程是并发执行，也即系统中各种进程轮流地占用解决器运营。
咱们把若干个进程都能进行访问和修改那些变量称为公共变量。由于进程是并发地执行，因此，如果对进程访问公共变量不加限制，那么就会产生“与时间关于”错误，即进程执行后所得到成果与访问公共变量时间关于。为了防止此类错误，系统必要要用同步机构来控制进程对公共变量访问。普通说，同步机构是由若干条原语——同步原语——所构成。本实验规定模仿PV操作同步机构实现，模仿进程并发执行，理解进程并发执行时同步机构作用。
本次用到数据构造知识如下：
typedef struct Pcb{
char name[10]； //进程名
char state[10]； //运营状态
char reason[10]； //若阻塞，其因素
int breakp； //断点保护
struct Pcb *next； //阻塞时顺序
}Pcb,*link；

进程名
状态
等待因素
断点
后继进程

进程控制块构造
定义两个进程： link p1;//生产者进程，link c1;//消费者进程。pc程序计数器和link ready；就绪队列，link b_s1；s1阻塞队列，link b_s2；s2阻塞队列。
实验指引：
a. h头文献
#include<string.h>
#include<ctype.h>
#include<malloc.h> /* malloc()等 */
#include<limits.h> /* INT_MAX等 */
#include<stdio.h> /* EOF(=^Z或F6),NULL */
#include<stdlib.h> /* atoi() */
#include<io.h> /* eof() */
#include<math.h> /* floor(),ceil(),abs() */
#include<process.h> /* exit() */
#include <iostream>
using namespace std;
#include <time.h>
#define BUF 10 //缓存大小
#define MAX 20 //最大可以输入字符

b. h头文献
//数据构造定义和全局变量
typedef struct Pcb{
char name[10]； //进程名
char state[10]； //运营状态
char reason[10]； //若阻塞，其因素
int breakp； //断点保护
struct Pcb *next； //阻塞时顺序
}Pcb,*link;
int s1,s2；//信号量
link p1;//生产者进程
link c1;//消费者进程
char str[MAX]；//输入字符串
char buffer[BUF]；//缓冲池
int len；//输入长度
int sp=0；//string指针
int in=0；//生产者指针
int out=0；//消费者指针
char temp；//供打印暂时产品
char rec_p[MAX];//生产记录
int rp1=0;//生产记录指针
char rec_c[MAX];//消费记录
int rp2=0;//消费记录指针
link ready；//就绪队列
link b_s1；//s1阻塞队列
link b_s2；//s2阻塞队列
int pc；//程序计数器
int count；//字符计数器
int con_cnt；//消费计数器
c. h头文献
void init()； //初始化
void p(int s)； //P操作
void v(int s)； //V操作
void block(int s);//阻塞函数
void wakeup(int s);//唤醒函数
void control()； //解决机调度
void processor();//解决机执行
void print()； //打印函数

void init(){ //初始化
s1=BUF;
s2=0;
p1=(link)malloc(sizeof(Pcb));//建立新结点,并初始化为生产者
strcpy(p1->name,"Producer");
strcpy(p1->state,"Ready");
strcpy(p1->reason,"Null");
p1->breakp=0;
p1->next=NULL;

c1=(link)malloc(sizeof(Pcb));//建立新结点,并初始化为消费者
strcpy(c1->name,"Consumer");
strcpy(c1->state,"Ready");
strcpy(c1->reason,"Null");
c1->breakp=0;
c1->next=NULL;

ready=p1;
ready->next=c1;//初始化为生产进程在前，消费进程在后
c1->next=NULL;
b_s1=NULL;
b_s2=NULL;//阻塞进程为NULL
pc=0;
con_cnt=0；//消费计数器
}

void p(int s){
if(s==1){ //p(s1)
s1--;
if(s1<0)
block(1)；//阻塞当前生产进程
else{
printf("\t* s1信号申请成功!\n");
ready->breakp=pc；//保存断点
}
}
else{ //p(s2)
s2--;
if(s2<0)
block(2);//阻塞当前消费进程
else{
printf("\t* s2信号申请成功!\n");
ready->breakp=pc；//保存断点
}
}
}

void v(int s){
if(s==1){ //v(s1)
s1++;
if(s1<=0)
wakeup(1)；//唤醒生产进程
ready->breakp=pc；//保存断点
}
else{ //v(s2)
s2++;
if(s2<=0)
wakeup(2);//唤醒消费进程
ready->breakp=pc；//保存断点
}
}

void block(int s){//阻塞函数定义
link p;
int num1=0;
int num2=0;
if(s==1){//生产进程
strcpy(p1->state,"Block");//变化状态
strcpy(p1->reason,"S1");//阐明因素
p=b_s1;
while(p){
num1++;
p=p->next;//p值为NULL,表达队尾
}
if(!b_s1)
b_s1=p1;
else
p=p1;
p1->next=NULL;
printf("\t* p1生产进程阻塞了!\n");
ready->breakp=pc；//保存断点
ready=ready->next;//在就绪队列中去掉,指向下一种
num1++;
}
else{//消费进程
strcpy(c1->state,"Block");
strcpy(c1->reason,"S2");
p=b_s2;
while(p){
num2++;
p=p->next;//p值为NULL,表达队尾
}
if(!b_s2)
b_s2=c1;
else
p=c1;
ready->breakp=pc；//保存断点
ready=ready->next;//在就绪队列中去掉,指向下一种
c1->next=NULL;
printf("\t* c1消费进程阻塞了!\n");
num2++;
}
printf("\t* 阻塞生产进程个数为:%d\n",num1);
printf("\t* 阻塞消费进程个数为:%d\n",num2);
}

void wakeup(int s){//唤醒函数定义
link p;
link q=ready;
if(s==1){ //唤醒b_s1队首进程,生产进程队列
p=b_s1;
b_s1=b_s1->next;//阻塞指针指向下一种阻塞进程
strcpy(p->state,"Ready");
strcpy(p->reason,"Null");
while(q)//插入就绪队列
q=q->next;
q=p;
p->next=NULL;
printf("\t* p1生产进程唤醒了!\n");
}
else{ //唤醒b_s2队首进程,消费进程队列
p=b_s2;
b_s2=b_s2->next;//阻塞指针指向下一种阻塞进程
strcpy(p->state,"Ready");
strcpy(p->reason,"Null");
while(q->next)//插入就绪队列
q=q->next;
q->next=p;
p->next=NULL;
printf("\t* c1消费进程唤醒了!\n");
}
}

void control() //解决器调度程序
{
int rd;
int num=0;

link p=ready;
if(ready==NULL) //若无就绪进程,结束
return;

while(p) //记录就绪进程个数
{
num++;
p=p->next;//最后p变为NULL
}
printf("\t* 就绪进程个数为:%d\n",num);

time_t t；
srand((unsigned) time(&t));
rd=rand()%num;//随机函数产生随机数
if(rd==1){
p=ready;
ready=ready->next;
ready->next=p;
p->next=NULL;
strcpy(ready->state,"Run");
strcpy(ready->next->state,"Ready");
}
else
strcpy(ready->state,"Run");
pc=ready->breakp;
}

void processor(){ //模仿解决器指令执行
if(strcmp(ready->name,"Producer")==0) //当迈进程为生产者
switch(pc)
{
case 0://produce
printf("\t* 生产者生产了字符%c\n",str[sp]);
rec_p[rp1]=str[sp];//添加到生产记录
sp=(sp+1)%len;
pc++;
ready->breakp=pc；//保存断点
break;
case 1：//p(s1)
pc++;
p(1);
break;
case 2：//put
buffer[in]=rec_p[rp1]；//放到缓冲区
printf("\t* %c字符成功入驻空缓存!\n",buffer[in]);
rp1++；
in=(in+1)%BUF;
pc++;
ready->breakp=pc；//保存断点
break;
case 3：//v(s2)
pc++;
printf("\t* 释放一种s2信号\n");
v(2);
break;
case 4://goto01
printf("\t* 生产进程goto 0 操作\n");
pc=0;
count--；//剩余字符个数减1
printf("\t* 剩余字符count=%d个\n",count);
ready->breakp=pc；//保存断点

if(count<=0){ //生产结束
printf("\t* 生产者结束生产!\n");
strcpy(p1->state,"Stop");
strcpy(p1->reason,"Null");
ready->breakp=-1;
ready=ready->next;//在就绪队列中去掉
}
}
else //当迈进程为消费者
switch(pc)
{
case 0：//p(s2)
pc++;
p(2)；
break;
case 1：//get
printf("\t* 消费者取字符!\n");
temp=buffer[out];
out=(out+1)%BUF;
pc++;
ready->breakp=pc；//保存断点
break;
case 2：//v(s1)
pc++;
printf("\t* 释放一种s1\n");
v(1);
break;
case 3：//consume
printf("\t* 消费了字符%c\n",temp);
rec_c[rp2]=temp;//添加到消费记录
rp2++;
con_cnt++;
if(con_cnt>=len){
strcpy(c1->state,"Stop");//完毕态
c1->breakp=-1;
return;
}
pc++;
ready->breakp=pc；//保存断点
break;
case 4：//goto0
printf("\t* 消费进程goto 0 操作\n");
pc=0;
ready->breakp=pc；//保存断点
}
}

void print(){
int i,j;
printf("--------生产者消费者模仿-------\n");
printf("* 模仿过程字符串为:\t");
printf("%s\n",&str);

printf("* 已生产:");
for(j=0;j<=rp1;j++)
printf("%c",rec_p[j]);
printf("\n* 空缓存:");
for(j=rp2;j<=rp1;j++)
printf("%c",buffer[j]);
printf("\n* 已消费:");
for(j=0;j<=rp2;j++)
printf("%c",rec_c[j]);
printf("\n-------进程控制块信息--------\n");
printf("进程名\t\t状态\t等待因素\t断点\n");
printf("%s\t%s\t%s\t\t%d\n\n",p1->name,p1->state,p1->reason,p1->breakp);
printf("%s\t%s\t%s\t\t%d\n",c1->name,c1->state,c1->reason,c1->breakp);
printf("-----------------------\n");
printf("1.继续 0.退出\n");
scanf("%d",&i);
if(i==0){
exit(0);
}
}
主程序
#include "a.h"
#include "b.h"
#include "c.h"
void main(){
printf("*生产者消费者模仿\n");
printf("---------\n");
printf("*请输入字符串:\n");
scanf("%s",str)； //string数组存储将要产生字符
len=strlen(str);
count=len； //输入字符个数
init()； //初始化
while(con_cnt<len) //消费完所有字符为结束
{
system("cls")； //清屏操作
printf("---------模仿指令流程--------\n");
control()； //解决器调度程序
processor()； //模仿解决器指令执行
print()； //输出显示各个信息
}
printf("\n程序结束!\n");
}

进程调度算法模仿
进程管理是操作系统中重要功能，用来创立进程、撤除进程、实现进程状态转换，它提供了在可运营进程之间复用CPU办法。在进程管理中，进程调度是核心，由于在采用多道程序设计系统中，往往有若干个进程同步处在就绪状态，当就绪进程个数不不大于解决器数目时，就必要依照某种方略决定哪些进程优先占用解决器。
本实验模仿在单解决器状况下进程调度，目是加深对进程调度工作理解，掌握不同调度算法优缺陷。
设计一种按先来先服务、时间片轮转法、优先数调度算法实现解决器调度程序。
实验指引：
#include<stdio.h>
#include<stdlib.h>
#include<string.h>
#include<conio.h>
typedef struct node
{
char name[10]； /*进程标记符*/
int prio； /*进程优先数*/
int round； /*进程时间轮转时间片*/
int cputime； /*进程占用CPU时间*/
int needtime； /*进程到完毕还要时间*/
int arrivetime； /*进程到达时间*/
int starttime； /*进程开始时间*/
int finishtime； /*进程完毕时间*/
int servicetime； /*进程服务时间*/
float turnaroundtime； /*进程周转时间*/
float weightedturnaroundtime； /*进程带权周转时间*/
int count； /*计数器*/
char state； /*进程状态*/
struct node *next； /*链指针*/
}PCB；
PCB *finish,*ready,*tail,*run； /*队列指针*/
int N； /*进程数*/
/*将就绪队列中第一种进程投入运营*/
void firstin()
{
run=ready； /*就绪队列头指针赋值给运营头指针*/
run->state='R'； /*进程状态变为运营态*/
ready=ready->next； /*就绪对列头指针后移到下一进程*/
}
/*****标题输出函数*****/
void prt1(char a)
{
switch(a)
{
case 1： /*优先数法*/
printf("名字 进程占用CPU时间 进程到完毕还要时间 优先级数 状态\n");break；
case 2： /*时间片算法*/
printf("名字 进程占用CPU时间 进程到完毕还要时间 计数器 时间片 状态\n");break;
case 3： /*先来先服务算法*/
printf("名字 到达时间 开始时间 服务时间 完毕时间 周转时间 带权周转时间 状态\n");break;
default:break;
}
}
/*****进程PCB输出*****/
void prt2(char a,PCB *q)
{
switch(a)
{
case 1：/*优先数法输出*/
printf("%-10s\t%-10d\t%-10d\t%-10d\t%c\n",q->name，
q->cputime,q->needtime,q->prio,q->state);break；
case 2:/*轮转法输出*/
printf("%-10s%-20d%-15d%-10d%-10d%-c\n",q->name，
q->cputime,q->needtime,q->count,q->round,q->state);break;
case 3:/*先来先服务算法输出*/
printf("%s%10d%10d%10d%10d%10.1f%10.2f\t\t%c\n",q->name,q->arrivetime,q->starttime,q->servicetime,q->finishtime,
q->turnaroundtime,q->weightedturnaroundtime,q->state);break;
default:break;
}
}
/*****输出函数*****/
void prt(char algo)
{
PCB *p；
prt1(algo)； /*输出标题*/
if(run!=NULL) /*如果运营指针不空*/
prt2(algo,run)；/*输出当前正在运营PCB*/
p=ready； /*输出就绪队列PCB*/
while(p!=NULL)
{
prt2(algo,p)；
p=p->next；
}
p=finish； /*输出完毕队列PCB*/
while(p!=NULL)
{
prt2(algo,p)；
p=p->next；
}
getch()； /*压任意键继续*/
}
/*****优先数插入算法*****/
void insert1(PCB *q)
{
PCB *p1,*s,*r；
int b；
s=q； /*待插入PCB指针*/
p1=ready；/*就绪队列头指针*/
r=p1；/*r做p1前驱指针*/
b=1；
while((p1!=NULL)&&b) /*依照优先数拟定插入位置*/
if(p1->prio>=s->prio)
{
r=p1；
p1=p1->next；
}
else
b=0；
if(r!=p1) /*如果条件成立阐明插入在r与p1之间*/
{
r->next=s；
s->next=p1；
}
else
{
s->next=p1； /*否则插入在就绪队列头*/
ready=s；
}
}
/*****轮转法插入函数*****/
void insert2(PCB *p2)
{
tail->next=p2； /*将新PCB插入在当前就绪队列尾*/
tail=p2；
p2->next=NULL；
}
/*****先来先服务插入函数*****/
void insert3(PCB *q)
{
PCB *p1,*s,*r;
int b;
s=q； /*指针s指向新要插入进程*/
p1=ready； /*指针p1指向本来进程对首*/
r=p1； /*使用指针r指向p1前面进程*/
b=1;
while((p1!=NULL)&&b)
if(p1->arrivetime<s->arrivetime)
{
r=p1;
p1=p1->next;
}
else
b=0;
if(r!=p1)
{
r->next=s;
s->next=p1;
}
else
{
s->next=p1;
ready=s;
}
}
/*****优先数创立初始PCB信息*****/
void create1(char alg)
{
PCB *p；
int i,time；
char na[10]；
ready=NULL；/*就绪队列头指针*/
finish=NULL； /*完毕队列头指针*/
run=NULL；/*运营队列头指针*/
printf("请输入进程名字和运营所需要时间\n")；/*输入进程标记和所需时间创立PCB*/
for(i=1;i<=N;i++)
{
p=(PCB *)malloc(sizeof(PCB))；
scanf("%s",na)；
scanf("%d",&time)；
strcpy(p->name,na)；
p->cputime=0；
p->needtime=time；
p->state='W'；
p->prio=50-time；
if(ready!=NULL) /*就绪队列不空则调用插入函数插入*/
insert1(p)；
else
{
p->next=ready；/*创立就绪队列第一种PCB*/
ready=p；
}
}
void clrscr(void);
printf(" 优先级调度算法模仿输出成果：\n")；
printf("*******************************************************************\n")；
prt(alg)； /*输出进程PCB信息*/
run=ready；/*将就绪队列第一种进程投入运营*/
ready=ready->next；
run->state='R'；
}
/*****轮转法创立进程PCB*****/
void create2(char al