操作系统实验全(包含源代码)
操作系统实验报告(全)
![操作系统实验报告(全)](https://img.taocdn.com/s3/m/a3b369f1f90f76c661371a6d.png)
操作系统实验报告书院系名称:电子工程学院电子指导教师:班级:学号:学生姓名:实验题目一:进程一、实验目的通过观察、分析实验现象,深入理解进程及进程在调度执行和内存空间等方面的特点,掌握在POSIX 规范中fork和kill系统调用的功能和使用。
二、实验内容(1)补充POSIX 下进程控制的残缺版实验程序(2)回答下列问题:1. 你最初认为运行结果会怎么样?2. 实际的结果什么样?有什么特点?试对产生该现象的原因进行分析。
3. proc_number 这个全局变量在各个子进程里的值相同吗?为什么?4. kill 命令在程序中使用了几次?每次的作用是什么?执行后的现象是什么?5. 使用kill 命令可以在进程的外部杀死进程。
进程怎样能主动退出?这两种退出方式哪种更好一些?三、实验步骤1.根据题意进入DOC环境中编写程序。
2.编译,链接,运行程序,进行调试。
3.分析实验结果及回答问题。
四、调试情况,回答问题及体会1、对自己设计进行评价,指出合理和不足之处,提出改进的方案。
2、在设计过程中的感受。
调试情况:回答上述实验内容中的问题1.预期结果:会持续输出0-9号进程,直到输入数字键+回车,则会杀死该进程,接下来的输出将不会有该进程号,当输入q+回车,则退出程序。
2.实际结果:与预期差不多,因输入进程总数20大于设定的最大进程数,因此按进程数10来处理。
随机输出0-9号进程,sleep(SLEEP_INTERV AL),循环输出,直到输入数字键,则会杀死该数字对应的进程,直到输入q退出循环,然后杀死本组所有进程。
分析:每创建一个子进程时,将其pid存储在pid[i]中,i存储在proc_number,然后调用死循环函数do_something(),输出该进程的代号proc_number;当输入数字键时,主进程会执行kill(pid[ch-'0'],SIGTERM),从而杀死(ch-‘0’)号进程。
北京邮电大学计算机学院 - 操作系统实验报告(含源代码)
![北京邮电大学计算机学院 - 操作系统实验报告(含源代码)](https://img.taocdn.com/s3/m/58bf15f5ba0d4a7302763a57.png)
1/58
10 年 12 月 19 日
内容目录
实验 1.3 Shell 编程...........................................................4 1、实验目的...............................................................4 2、实验内容...............................................................4 3、实验原理...............................................................4 4、实验步骤...............................................................4 5、实验结果:.............................................................4 6、人员任务分配...........................................................5
实验项目:
1. 实验 1.3 Shell 编程 2. 实验 2.3 内核模块 3. 实验 2.4 系统调用 4. 实验 3.3 Shell 编程实验(进程管理实验) 5. 实验 4.1 观察实验(存储管理实验) 6. 实验 5.1 观察实验(进程通信) 7. 实验 6.3 Io 系统编程实验 8. 实验 6.4 设备驱动程序 9. 实验 7.1 代码分析(文件系统管理实验)
实验 3.3 Shell 编程实验(进程管理实验)......................................18 1、实验目的..............................................................18 2、实验内容..............................................................18 3、实验原理..............................................................18 4、实验步骤..............................................................18 5、实验结果及分析........................................................19 6、人员任务分配..........................................................19 2、实验内容 2............................................................20 3、实验原理..............................................................20 4、实验步骤..............................................................20 5、实验结果及分析........................................................23 6、人员分配..............................................................24
51单片机操作系统的实现+源代码
![51单片机操作系统的实现+源代码](https://img.taocdn.com/s3/m/76d6de50312b3169a451a415.png)
51单片机操作系统开发中的问题与技巧附代码引言51系列单片机是美国Intel公司在1980年推出的高性能8位单片机,在我国的应用非常广泛。
目前,在软件设计中需要软件工程师从底层做起,在系统软件设计方面需要做大量的重复性劳动。
如果开发一套基于51系列单片机的操作系统,那么用户只需要编写各个任务的程序,不必同时将所有任务运行的各种情况记在心中,不但大大减少了程序编写的工作量,而且减少了出错的可能性。
1 开发平台的选择和论证开发平台的选择至关重要,因为有时它不光影响进度、产品质量、可维护性等一般问题,还涉及到方案的可实现性。
在本系统中,选择51系列单片机作为操作系统的运行平台有以下原因。
首先,51系列单片机应用非常广泛,一大批性能优越的51兼容单片机相继推出。
这里包括:低功耗、高速度和增强型的Philips公司的系列产品;完美地将Flash(非易失闪存技术)EEPROM与80C51内核结合起来的Atmel公司的系列产品;在抗干扰性能,电磁兼容和通信控制总线功能上独树一帜,其产品常用于工作环境恶劣场合的Siemens公司的系列产品以及一些其它公司的产品。
既然产品如此丰富,性能如此优越,那么在处理多任务并且对实时性要求严格的系统设计中,为了充分挖掘单片机的潜能(尤其是在实时性方面),也是为了简化开发的过程,基于51系列单片机的实时操作系统的需求就十分强烈了。
Keil公司的RTX51 Full就是一个基于51系列单片机的有实用价值的实时操作系统,但该操作系统是一个源码不公开的收费软件。
其次,借助于Keil C51的集成开发环境,完全可以开发出适用于51系列单片机的操作系统代码。
Keil C51软件提供丰富的库函数和功能强大的Windows界面集成开发调试工具。
另外重要的一点,Keil C51生成的目标代码效率非常高,多数语句生成的汇编代码很紧凑,容易理解。
在开发大型软件时,更能体现高级语言的优势。
C编译器能产生可重入代码,而且用C语言可以打开和关闭中断。
(完整word版)进程管理实验报告源代码
![(完整word版)进程管理实验报告源代码](https://img.taocdn.com/s3/m/2edd85b7da38376bae1fae3d.png)
实验一进程管理1.目的和要求通过实验理解进程的概念,进程的组成(PCB结构),进程的并发执行和操作系统进行进程管理的相关原语(主要是进程的创建、执行、撤消)。
2.实验内容用C语言编程模拟进程管理,至少要有:创建新的进程;查看运行进程;换出某个进程;杀死运行进程以及进程之间通信等功能。
3.实验环境Windows操作系统、VC++6.0C语言4.实验提示PCB结构通常包括以下信息:进程名,进程优先数,轮转时间片,进程所占用的CPU时间,进程的状态,当前队列指针等。
可根据实验的不同,PCB结构的内容可以作适当的增删。
主体程序#include "conio.h"#include "stdio.h"#include "stdlib.h"struct jincheng_type{int pid;int youxian;int daxiao;int msg;int live;};struct jincheng_type neicun[20],waicun[20];int shumu=0,pid_l;main(){int n,m,i;char a;n=1;while(n==1){system("cls");printf("\n********************************************");printf("\n* 进程演示系统*");printf("\n********************************************");printf("\n 1.创建新的进程 2.查看运行进程");printf("\n 3.换出某个进程 4.杀死运行进程");printf("\n 5.进程之间通信 6.退出");printf("\n********************************************");printf("\n请选择(1~6) ");a=getch();switch(a){case'1':create( );break;case'2':viewrun( );break;case'3':huanchu();break;case'4':kill( );break;case'5':tongxun( );break;case'6': exit(0);default: n=0;}}}create( ) /* 创建一个进程的示例(不完整的程序)*/ {if(shumu>=20){printf("\n内存已满,请先结束或换出进程\n");}else{printf("\n请输入新进程的pid\n");scanf("%d",&neicun[shumu+1].pid);printf("\n请输入新进程的优先级\n");scanf("%d",&neicun[shumu+1].youxian);printf("\n请输入新进程的大小\n");scanf("%d",&neicun[shumu+1].daxiao);printf("\n请输入新进程的消息\n");scanf("%d",&neicun[shumu+1].msg);neicun[shumu+1].live=1;shumu++;}return neicun[shumu-1].live;}viewrun( )/*查看运行进程*/{int vpid;printf("\n请输入进程的pid\n");scanf("%d",&vpid);if(vpid>0&&vpid<=20&&neicun[vpid].live==1){printf("\n进程的pid是: %d\n",neicun[vpid].pid);printf("进程的优先级是: %d\n",neicun[vpid].youxian);printf("进程的大小是:%d\n",neicun[vpid].daxiao);printf("进程的消息是:%d\n",neicun[vpid].msg);}else{printf("\n所查看运行进程不存在\n");}printf("请按回车退出查看\n");vpid=getch();}huanchu()/*换出某个进程*/{int pid1,pid2;char c;printf("\n请输入第一个替换进程的pid\n");scanf("%d",&pid1);printf("\n请输入第二个替换进程的pid\n");scanf("%d",&pid2);if(pid1>0&&pid1<=20&&neicun[pid1].live==1){if(neicun[pid1].youxian>neicun[pid2].youxian){waicun[20].pid=neicun[pid1].pid;waicun[20].youxian=neicun[pid1].youxian;waicun[20].daxiao=neicun[pid1].daxiao;waicun[20].msg=neicun[pid1].msg;neicun[pid1].pid=neicun[pid2].pid;neicun[pid1].youxian=neicun[pid2].youxian;neicun[pid1].daxiao=neicun[pid2].daxiao;neicun[pid1].msg=neicun[pid2].msg;neicun[pid2].pid=waicun[20].pid;neicun[pid2].youxian=waicun[20].youxian;neicun[pid2].daxiao=waicun[20].daxiao;neicun[pid2].msg=waicun[20].msg;printf("\n替换完成\n");printf("\n被替换进程的pid是: %d\n",waicun[20].pid); printf("被替换进程的优先级是: %d\n",waicun[20].youxian); printf("被替换进程的大小是:%d\n",waicun[20].daxiao); printf("被替换进程的消息是:%d\n",waicun[20].msg);}else{printf("\n进程优先级不够大");}}else{printf("所查看运行进程不存在");}printf("请按回车退出换出进程\n");c=getche();return;}kill()/*杀死运行进程*/{int kpid;printf("\n请输入进程的pid\n");scanf("%d",&kpid);if(kpid>0&&kpid<20&&neicun[kpid].live==1){neicun[kpid].live=0;}return;}tongxun( )/*进程之间通信*/{int tpid1,tpid2;int buffer;char d;printf("\n请输入通信源进程pid\n");scanf("%d",&tpid1);printf("\n请输入通信目的进程pid\n");scanf("%d",&tpid2);if(tpid1>0&&tpid1<20&&neicun[tpid1].live==1){buffer=neicun[tpid1].msg;neicun[tpid1].msg=neicun[tpid2].msg;neicun[tpid2].msg=buffer;printf("\n源进程的消息是: %d\n",neicun[tpid1].msg);printf("\n目的进程的消息是: %d\n",neicun[tpid2].msg);}else{printf("\n所查看运行进程不存在\n");}printf("\n请按回车退出进程通信\n");d=getch();return;}5.实验运行结果******************************************** * 进程演示系统* ********************************************1.创建新的进程2.查看运行进程3.换出某个进程4.杀死运行进程5.进程之间通信6.退出系统******************************************** 请选择(1~6)然后根据你选择的不同,出现不同的结果。
操作系统实验
![操作系统实验](https://img.taocdn.com/s3/m/210a7f4633687e21af45a942.png)
操作系统实验报告实验一进程控制与描述一、实验目的通过对Windows 2000编程,进一步熟悉操作系统的基本概念,较好地理解Windows 2000的结构。
通过创建进程、观察正在运行的进程和终止进程的程序设计和调试操作,进一步熟悉操作系统的进程概念,理解Windows 2000中进程的“一生”。
二、实验环境硬件环境:计算机一台,局域网环境;软件环境:Windows 2000 Professional、Visual C++ 6.0企业版。
三、实验内容和步骤第一部分(共三个程序):Windows 2000 Professional下的GUI应用程序,使用Visual C++编译器创建一个GUI 应用程序,代码中包括了WinMain()方法,该方法GUI类型的应用程序的标准入口点。
程序1-1# include <windows.h># pragma comment(lib, “user32.lib” )int APIENTRY WinMain(HINSTANCE /* hInstance */ ,HINSTANCE /* hPrevInstance */,LPSTR /* lpCmdLine */,int /* nCmdShow */ ){:: MessageBox(NULL,“Hello, Windows 2000” ,“Greetings”,MB_OK) ;return(0) ; }实验结果然后改变参数,运行结果如下:1-2显示了当前进程的优先级:1-3进一步显示进程的具体情况:第二部分:进程的“一生”(共三个程序)1、创建进程本程序展示的是一个简单的使用CreateProcess() API函数的例子。
首先形成简单的命令行,提供当前的EXE文件的指定文件名和代表生成克隆进程的号码。
大多数参数都可取缺省值,但是创建标志参数使用了:BOOL bCreateOK标志,指示新进程分配它自己的控制台,这使得运行示例程序时,在任务栏上产生许多活动标记。
操作系统上机实验报告
![操作系统上机实验报告](https://img.taocdn.com/s3/m/ff72a6571fb91a37f111f18583d049649b660e3a.png)
操作系统上机实验报告实验一进程的建立1.实验目的学会通过基本的Windows进程控制函数,由父进程创建子进程,并实现父子进程协同工作。
2.实验软硬件环境Dev-C++3.实验内容创建两个进程,让子进程读取一个文件,父进程等待子进程读取完文件后继续执行,实现进程协同工作。
进程协同工作就是协调好两个进程,使之安排好先后次序并以此执行,可以用等待函数来实现这一点。
当需要等待子进程运行结束时,可在父进程中调用等待函数。
4.实验程序及分析实验程序源代码如下:父进程:#include<stdio.h>#include<windows.h>int main(){STARTUPINFO si;PROCESS_INFORMA TION pi; //当Windows创建新进程时,将使用这两个结构体的有关成员。
所以在创建子进程之前应该对结构体进行声明和初始化。
ZeroMemory(&pi,sizeof(pi));ZeroMemory(&si,sizeof(si));si.cb=sizeof(STARTUPINFO);if(CreateProcess("lab1.2.exe",NULL,NULL,NULL,FALSE,CREATE_NEW_CONSOLE,NULL ,NULL,&si,&pi))//创建一个新进程,若是成功,就返回1,进而实现if选择{printf("子进程已创建~\n");int i,sum=0;for(i=1;i<=100;++i){sum+=i;printf("sum=%d\n",sum);} //进行1+2+3+….+100计算WaitForSingleObject(pi.hProcess,INFINITE); FILE *fp;fp=fopen("date.txt","r");char ch=fgetc(fp); //创建文件并打开while(ch!=EOF){putchar(ch);ch=fgetc(fp);}fclose(fp); //关闭文件}elseprintf("子进程创建失败~\n");return 0;}子进程:#include<stdio.h>#include<stdlib.h>int main(){printf("子进程运行~\n");FILE *fp;if(fp=fopen("date.txt","w")){printf("已经创建文件!\n");int i;for(i=48;i<58;i++) fputc(i,fp);fputc('\n',fp);fclose(fp);printf("已经写入数据:"); //向文本中写入数据fp=fopen("date.txt","r");char ch=fgetc(fp);while(ch!=EOF){putchar(ch);ch=fgetc(fp); //输出数据}fclose(fp);}else printf("创建文件失败!\n");system("pause");return 0;}5. 实验截图说明及分析6. 实验心得体会掌握了父进程创建子进程的方法,对操作系统多线程认识更深了。
操作系统课程设计-银行家算法(流程图+源代码+设计报告)
![操作系统课程设计-银行家算法(流程图+源代码+设计报告)](https://img.taocdn.com/s3/m/802c4df94693daef5ef73d95.png)
操作系统课程设计-银行家算法(流程图+源代码+设计报告)一、实验目的:熟悉银行家算法,理解系统产生死锁的原因及避免死锁的方法,加深记意。
二、实验要求:用高级语言编写和调试一个描述银行家算法的程序。
三、实验内容:1、设计一个结构体,用于描述每个进程对资源的要求分配情况。
包括:进程名--name[5],要求资源数目--command[m](m类资源),还需要资源数目--need[m],已分配资源数目--allo[m]。
2、编写三个算法,分别用以完成:①申请资源;②显示资源;③释放资源。
(动态完成)四、程序流程图五、源程序:最新版本:bk5.c/*bk2.c::可以自定义进程及资源数目,可选择读文件或创建新文件,但不超过10,5*//*可修改# define NP 10*//* # define NS 5 */ /*资源种类*//*bk3.c::可以继续分配资源(〉2)*//*bk4.c::可保存分析结果*//*bk5.c::除以上功能外,对暂时不能分配的可以进行另外一次尝试,并恢复已分配的资源*/ /*四、程序流程图:五、源程序:最新版本:bk5.c/*bk2.c::可以自定义进程及资源数目,可选择读文件或创建新文件,但不超过10,5*//*可修改# define NP 10*//* # define NS 5 */ /*资源种类*//*bk3.c::可以继续分配资源(〉2)*//*bk4.c::可保存分析结果*//*bk5.c::除以上功能外,对暂时不能分配的可以进行另外一次尝试,并恢复已分配的资源*/ #include "string.h"#include "stdio.h"#include "dos.h"#include "conio.h"#define MOVEIN 1#define GUIYUE 2#define ACC 3#define OK 1#define ERROR 0#define MAXSH 7#define MAXSHL 10#define MAXINPUT 50#define maxsize 100int act;int ip=0;int line=0; /*line为要写的行号,全局变量*/int writeok;int right;char wel[30] = {"Welcome To Use An_Li System"};char ente[76]={" 警告:未经作者同意不得随意复制更改!"};char rights[40]={"Copyright (c) 2002"};struct date today;struct time now;typedef struct{int data[maxsize];int top;}stack;int emptystack(stack *S){if(S->top==48&&S->data[S->top]==35)return(1); /*35 is '#'*/ else return(0);}int push(stack *S,int x){if(S->top>=maxsize-1)return(-1);else{S->top++;S->data[S->top]=x;return(0);}}int gettop(stack *S){return S->data[S->top];}int pop(stack *S){if(emptystack(S)){printf("the stack is empty\n");exit(1);}else S->top--;return S->data[S->top+1];}void initstack(stack *S){int i;S->top=0;S->data[S->top]=35;}/*****模拟打字机的效果*********/delay_fun(){int i;void music();for(i=0;;i++){if(wel!='\0'){delay(1000);textcolor(YELLOW);gotoxy(26+i,8);cprintf("%c",wel);printf("谢谢");printf("网络 ");music(1,60);}else break;}delay(500000);for(i=0; ; i++){if(ente!='\0'){delay(1000);textcolor(RED);/*显示警告及版权*/ gotoxy(2+i,11);cprintf("%c",ente);music(1,60);}else break;}delay(40000);for(i=0;;i++){if(rights != '\0'){delay(1000);textcolor(YELLOW);gotoxy(30+i,14);cprintf("%c",rights);music(1,60);}elsebreak;}getch();}/*********登陆后的效果**********/logined(){ int i;clrscr();gotoxy(28,10);textcolor(YELLOW);cprintf("程序正在载入请稍候.....");gotoxy(35,12);for(i=0;i<=50;i++){gotoxy(40,12);delay(8000);cprintf("%02d%已完成",i*2);gotoxy(i+15,13);cprintf("\n");cprintf("|");}main0();}/*********对PC扬声器操作的函数****/void music(int loop,int f) /* f为频率*/{ int i;for(i=0;i<30*loop;i++){sound(f*20);delay(200);}nosound();}int analys(int s,int a){int hh,pos;switch(a){case (int)'i':hh=0;break;case (int)'+':hh=1;break;case (int)'*':hh=2;break;case (int)'(':hh=3;break;case (int)')':hh=4;break;case (int)'#':hh=5;break;case (int)'E':hh=6;break;case (int)'T':hh=7;break;case (int)'F':hh=8;break;default:{printf(" \n analys()分析发现不该有的字符 %c !(位置:%d)",a,ip+1); writeerror('0',"\n............分析出现错误!!!");writeerror(a,"\n 错误类型: 不该有字符 ");printf("谢谢");printf("网 ");return ERROR;}}pos=(s-48)*10+hh;switch(pos){case 3:case 43:case 63:case 73:act=4;return MOVEIN;case 0:case 40:case 60:case 70:act=5;return MOVEIN;case 11:case 81: act=6;return MOVEIN;case 92:case 22:act=7;return MOVEIN;case 84:act=11;return MOVEIN;/*-------------------------------------------*/ case 91:case 94:case 95:act=1;return GUIYUE;case 21:case 24:case 25:act=2;return GUIYUE;case 101:case 102:case 104:case 105:act=3;return GUIYUE;case 31:case 32:case 34:case 35:act=4;return GUIYUE;case 111:case 112:case 114:case 115:act=5;return GUIYUE;case 51:case 52:case 54:case 55:act=6;return GUIYUE;/*+++++++++++++++++*/case 15:return ACC;/*******************************/case 6:return 1;case 7:case 47:return 2;case 8:case 48:case 68:return 3;case 46:return 8;case 67:return 9;case 78:return 10;default:{if(a=='#')printf("");else printf(" \n analys() 分析发现字符%c 不是所期望的!(位置:%d)",a,ip+1);writeerror('0',"\n ...........分析出现错误!!!");writeerror(a,"\n 错误类型: 字符 ");writeerror('0'," 不是所期望的! ");printf("谢谢");printf("网 ");return ERROR;}}}int writefile(int a,char *st){FILE *fp;fp=fopen("an_slr.txt","a");if(fp==0){printf("\nwrite error!!");writeok=0;}else{if(a==-1){fprintf(fp," %s ",st); /*若a==-1则为添加的注释*/}else if(a==-2){getdate(&today);gettime(&now);fprintf(fp,"\n 测试日期: %d-%d-%d",today.da_year,today.da_mon,today.da_day); fprintf(fp," 测试时间:%02d:%02d:%02d",now.ti_hour,now.ti_min,now.ti_sec);}else if(a>=0) fprintf(fp,"\n step: %02d , %s",a,st);writeok=1;fclose(fp);}return writeok;}int writeerror(char a,char *st) /*错误类型文件*/{FILE *fpp;fpp=fopen("an_slr.txt","a");if(fpp==0){printf("\nwrite error!!");writeok=0;}else{if(a=='0') fprintf(fpp," %s ",st); /*若a=='0' 则为添加的注释*/else fprintf(fpp," %s \'%c\'(位置:%d) ",st,a,ip+1);writeok=1;fclose(fpp);}return writeok;}/*^^^^^^^^^^^^^^^^^^^^^^*/main0(){int an,flag=1,action,lenr;char a,w[MAXINPUT];int len,s,ss,aa,ana;stack *st;char r[MAXSH][MAXSHL]; /*初始化产生式*/strcpy(r[0],"S->E");strcpy(r[1],"E->E+T");strcpy(r[2],"E->T");strcpy(r[3],"T->T*F");strcpy(r[4],"T->F");strcpy(r[5],"F->(E)");strcpy(r[6],"F->i");clrscr();printf("\nplease input analyse string:\n");gets(w);len=strlen(w);w[len]='#';w[len+1]='\0';initstack(st);push(st,48); /* (int)0 进栈*/writefile(-1,"\n------------------------SLR(1)词法分析器-------------------------");writefile(-1,"\n 计本003 安完成于2003.01.12 14:04");writefile(-1,"\n谢谢");writefile(-1,"网 ");writefile(-1,"\n 以下为串");writefile(-1,w);writefile(-1,"('#'为系统添加)的分析结果: ");writefile(-2," ");do{s=gettop(st);aa=(int)w[ip];action=analys(s,aa);if(action==MOVEIN){ss=48+act;push(st,aa);push(st,ss); /* if ss=4 int =52 */ip++;}else if(action==GUIYUE){lenr=strlen(r[act])-3;for(an=0;an<=2*lenr-1;an++)pop(st); /* #0 */s=gettop(st); /* s=0 */push(st,(int)r[act][0]);/*将产生式左端 F 进栈 */ana=analys(s,(int)r[act][0])+48;if(ana>59)printf("\分析出错:ana>59!!!");push(st,ana);/*analys(s,aa)即为goto(s',aa) */if((line+1)%20==0){printf("\nThis screen is full,press any key to continue!!!");getche();clrscr();}printf(" step %02d: %s\n",line++,r[act]);writefile(line,r[act]);}else if(action==ACC){flag=0;right=1;}else if(action==ERROR){flag=0;right=0;} /*接受成功*/else{flag=0;right=0;} /* 出错*/}while(flag==1);if(right==1)printf("\nok,输入串 %s 为可接受串!!",w);if(right==0)printf("\nsorry,输入串 %s 分析出错!!",w);if(writeok==1){printf("\nAnWin soft have wrote a file an_slr.txt");if(right==1)writefile(-1,"\n最终结果:输入串为可接受串!"); }}main() /*主函数*/{clrscr();delay_fun();logined();}六、测试报告-操作系统课程设计-银行家算法(流程图+源代码+设计报告)六、测试报告:(测试结果保存于系统生成的an.txt 文件中)以下为课本上的实例::-------------------------------------------------------------------------------------========================银行家算法测试结果=========================-------------------------------------------------------------------------------------T0 时刻可用资源(Available) A:3, B:3, C:2测试日期: 2003-6-28 请求分配时间: 14:07:29经测试,可为该进程分配资源。
操作系统实验指导书及代码
![操作系统实验指导书及代码](https://img.taocdn.com/s3/m/25b6accf52d380eb63946dbf.png)
操作系统实验指导书及代码《操作系统》实验指导书目录实验环境 ................................................. 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块来调度进程。
操作系统实习报告(源代码)
![操作系统实习报告(源代码)](https://img.taocdn.com/s3/m/6fb6e2ca0508763231121200.png)
#define false 0#define true 1#include "stdio.h"typedef struct{char name[3]; /*文件或目录名*/char type[2]; /*文件类型名*/char attribute; /*属性*/char address; /*文件或目录的起始盘块号*/char length; /*文件长度,以盘块为单位*/}content; /*目录结构*/#define n 5 /*模拟实验中系统允许打开文件的最大数量*/typedef struct{int dnum; /*磁盘盘块号*/int bnum; /*盘块内第几项*/}pointer; /*已打开文件表中读写指针的结构*/typedef struct{char name[20]; /*文件绝对路径名*/char attribute;/*文件的属性,用1个字节表示,所以用了char类型*/int number; /*文件起始盘块号*/int length; /*文件长度,文件占用的字节数*/int flag; /*操作类型,用"0"表示以读操作方式开文件,用"1"表示写操作方式打开文件*/ pointer read; /*读文件的位置,文件刚打开时dnum为文件起始盘块号,bnum为"0"*/ pointer write; /*写文件的位置,文件建立时dnum为文件起始盘块号,bnum为"0",打开时为文件末尾*/}OFILE; /*已打开文件表项类型定义*/struct{OFILE file[n]; /*已打开文件表*/int length; /*已打开文件表中登记的文件数量*/}openfile; /*已打开文件表定义*/char buffer1[64];/*模拟缓冲1*/content buffer2[8];/*模拟缓冲2*/FILE *fc; /*模拟磁盘的文件指针*/void copen(OFILE *x1,OFILE *x2)OFILE *x1,*x2;{strcpy(x1->name,x2->name);x1->attribute=x2->attribute;x1->number=x2->number;x1->length=x2->length;x1->flag=x2->flag;x1->read.dnum=x2->read.dnum;x1->read.bnum=x2->read.bnum;x1->write.dnum=x2->write.dnum;x1->write.bnum=x2->write.bnum;}sopen(name)/*在已打开文件表中查找文件name*/char *name;{int i;i=0;while(i<openfile.length&&strcmp(openfile.file[i].name,name)!=0)/*依次查找已打开文件表*/i++;if(i>=openfile.length)return(-1);return(i);}/*查找sopen函数结束*/dopen(name)/*在已打开文件表中删除文件name*/char *name;{int i;i=sopen(name);if(i==-1)printf("文件未打开/n");else{copen(&openfile.file[i],&openfile.file[openfile.length-1]);openfile.length--;}}/*删除函数结束*/iopen(x)/*在已打开文件表中插入文件name*/content *x;{int i;i=sopen(x->name);if(i!=-1){printf("文件已经打开/n");return(false);}else if(openfile.length==n){printf("已打开文件表已满/n");return(false);}else{copen(&openfile.file[openfile.length],x);openfile.length++;return(true);}}/*填写已打开文件表函数结束*/allocate( )/*分配一个磁盘块,返回块号*/{int i;fseek(fc,0,SEEK_SET); /*将模拟磁盘的文件指针移至模拟磁盘FAT表*/fread(buffer1,64L,1,fc);/*将FAT表中第一个磁盘块读入模拟缓冲buffer1中*/for(i=3;i<63;i++)if(buffer1[i]==0){ /*FAT中的第i项为0,分配第i块磁盘块,修改FAT表,并且写回磁盘*/buffer1[i]=255;fseek(fc,0,SEEK_SET);fwrite (buffer1,64L,1,fc);return(i); /*返回磁盘号*/}fread(buffer1,64L,1,fc);/*将FAT表中第二个磁盘块读入模拟缓冲buffer1中*/for(i=0;i<63;i++)if(buffer1[i]==0){/*FAT中的第i项为0,分配第i+64块磁盘块,修改FAT表,并且写回磁盘*/ buffer1[i]=255;fseek(fc,-64L,SEEK_CUR);fwrite(buffer1,64L,1,fc);return(i+64); /*返回磁盘号*/}printf("已经没有磁盘空间/n");return(false);}/*分配磁盘块函数结束*/read_file(name,length)/*读文件函数,文件路径名name,读取长度length*/char *name;int length;{int i,t;char ch;if((i=sopen(name))==-1){printf("文件没有打开或不存在/n");return(false);}if(openfile.file[i].flag==1){printf("文件以写方式打开,不能读/n");return(false);}t=0;fseek(fc,openfile.file[i].read.dnum*64L,SEEK_SET);fread(buffer1,64,1,fc);while(t<length&&buffer1[openfile.file[i].read.bnum]!='#'){putchar(buffer1[openfile.file[i].read.bnum]);/*读出一个字符(这里是在屏幕上显示)*/if((t+1)%64==0)putchar('/n');/*修改读指针*/openfile.file[i].read.bnum++;if(openfile.file[i].read.bnum>=64)/*一块读完,读取下一个盘块*/{fseek(fc,openfile.file[i].read.dnum/64*64, SEEK_SET);fread(buffer1,64,1,fc);openfile.file[i].read.dnum=buffer1[openfile.file[i].read.dnum%64];/*修改读指针*/openfile.file[i].read.bnum=0;fseek(fc,openfile.file[i].read.dnum*64L,SEEK_SET);fread(buffer1,64,1,fc);/*读取下一个*/}t++;}}/*读函数结束*/write_file(name,buff,length)/*写文件函数*/char *name;/*文件路径名*/char *buff;/*存放准备写入磁盘的内容*/int length;/*写入内容的长度*/{int i,t,dd;if((i=sopen(name))==-1)/*文件不存在,无法写*/{printf("文件没有打开或不存在/n");return(false);}if(openfile.file[i].flag==0){printf("文件以读方式打开,不能写/n");return(false);}t=0;fseek(fc,openfile.file[i].write.dnum*64L, SEEK_SET);fread(buffer1,64,1,fc);while(t<length){buffer1[openfile.file[i].write.bnum]=buff[t];openfile.file[i].write.bnum++;openfile.file[i].length++;if(openfile.file[i].write.bnum>=64){fseek(fc, openfile.file[i].write.dnum*64L, SEEK_SET);fwrite(buffer1,64,1,fc);/*一块写完,写回磁盘*/if((dd=allocate())==false){openfile.file[i].write.bnum--;openfile.file[i].length--;printf("无磁盘空间,部分信息丢失,写失败/n");return(false);}/*if*/fseek(fc,openfile.file[i].write.dnum/64*64L, SEEK_SET);fread(buffer1,64,1,fc);buffer1[openfile.file[i].write.dnum%64]=dd;fseek(fc,openfile.file[i].write.dnum/64*64L, SEEK_SET);fwrite(buffer1,64,1,fc);openfile.file[i].write.dnum=dd;openfile.file[i].write.bnum=0;}/*if*/t++;}/*while*/fseek(fc, openfile.file[i].write.dnum*64L, SEEK_SET);fwrite(buffer1,64,1,fc);/*一块写完,写回磁盘*/}/*写函数结束*/search(name,flag,dnum,bnum)/*查找路径名为name的文件或目录,返回该目录的起始盘块号*/char *name;int flag; /*flag=8表示查找目录,否则为文件*/int *dnum,*bnum;/*返回找到文件或目录的目录项的位置:盘块dnum中第bnum项*/ {int k,i,s,t,j,last=0;char pna[3],type[2];if((strcmp(name,"")==0)||(strcmp(name,"/")==0))/*根目录*/return(2);k=0;if(name[0]=='/')k=1;i=2; /*i=根目录的起始盘块号*/while(last!=1){/*pna=从name中分离出"/"后一个目录名(或文件名)*/for(s=0;name[k]!='.'&&name[k]!='/'&&s<3&&name[k]!='/0';s++,k++)pna[s]=name[k];for(;s<3;s++)/*用空格补全名字长度*/pna[s]=' ';while(name[k]!='.'&&name[k]!='/0'&&name[k]!='/')/*除去多余字符*/k++;type[0]=type[1]=' ';if(name[k]=='.')/*取文件类型名type*/if(flag==8){printf("目录不应该有有类型名,查找失败/n");return(false);}else{/*文件遇到类型名认为结束,后面的字符作废*/k++;if(name[k]!='/0')type[0]=name[k];k++;if(name[k]!='/0')type[1]=name[k];if(name[k]!='/0'&&name[k+1]!='/0'){printf("文件名错误/n");return(false);}last=1;}elseif(name[k]!='/0')k++;if(name[k]=='/0')last=1;/*查找目录且名字等于pna的目录项*/fseek(fc,i*64L,SEEK_SET);fread(buffer2,64L,1,fc);j=0;if(last==1&&flag!=8)while(j<8&&!(buffer2[j].attribute!=8&&buffer2[j].name[0]==pna[0]&&buffer2[j].name[1]==pna[1]&&buffer2[j].name[2]==pna[2]&&buffer2[j].type[0]==type[0]&&buffer2[j].type[1]==type[1]))j++;elsewhile(j<8&&!(buffer2[j].attribute==8&&buffer2[j].name[0]==pna[0]&&buffer2[j].name[1]= =pna[1]&&buffer2[j].name[2]==pna[2]))j++;if(j<8)/*找到该目录或文件*/if(last==1)/*查找结束*/{*dnum=i;*bnum=j;return(buffer2[j].address);}else/*查找还未结束*/i=buffer2[j].address;/*读取下一个盘块*/elsereturn(false);}/*while 查找结束*/}/*search()结束*/create_file(name,attribute)/*建立文件函数,路径名name,文件属性attribute*/char *name;int attribute;{int dnum,bnum,i,j,last,k,s,d,t,tt,b,dd,flag,dn,bn;char dname[3],tname[2],pathname[20];OFILE x;if(attribute%2==1){printf("只读文件,无法写,不能建立/n");return(false);}if(openfile.length==n){printf("已打开表已满,不能建立/n");return(false);}/* 将name分成两部分,目录路径pathname和目录名dname*/for(j=0;name[j]!='/0';j++)/*查找最后一个"/"*/if(name[j]=='/')s=j;/*分离目录路径*/for(j=0;j<s;j++)pathname[j]=name[j];pathname[j]='/0';/*分离文件名*/for(k=0,j=s+1;name[j]!='/0'&&k<3&&name[j]!='.';j++,k++)dname[k]=name[j];if(k==0){printf("错误文件名或目录名/n");return(false);}for(;k<3;k++)dname[k]=' ';k=0;if(name[j++]=='.')/*分离类型名*/{for(;name[j]!='/0'&&k<2&&name[j]!='.';j++,k++)tname[k]=name[j];}for(;k<2;k++)tname[k]=' ';if((d=search(pathname,8,&dn,&bn))==false)/*找到目录路径,返回该目录所在块号dn 和项数bn*/{printf("目录不存在,不能建立");return(false);}/*确认该目录不存在的同时查找空目录项*/b=-1;fseek(fc,d*64L,SEEK_SET);fread(buffer2,64L,1,fc); /*读出dnum盘块的内容*/for(t=0;t<8;t++){if(buffer2[t].name[0]==dname[0]&&buffer2[t].name[1]==dname[1]&&buffer2[t].name[2]== dname[2]&&buffer2[t].type[0]==tname[0]&&buffer2[t].type[1]==tname[1]){/*找到名字dname的文件,建立失败*/printf("文件已经存在,不能建立/n");return(false);}if(buffer2[t].name[0]=='$'&&b==-1)b=t;}/*for*/if(b==-1)/*没有空目录项,建立失败*/{printf("目录无空间/n");return(false);}if((dd=allocate( ))==false)/*分配给建立目录的磁盘盘块dd*/{printf("建立文件失败/n");return(false);}/*填写目录项*/for(i=0;i<3;i++)buffer2[b].name[i]=dname[i];for(i=0;i<2;i++)buffer2[b].type[i]=tname[i];buffer2[b].attribute=attribute;buffer2[b].address=dd;buffer2[b].length=0;fseek(fc,d*64L,SEEK_SET);fwrite(buffer2,64L,1,fc);/*填写已打开文件表*/strcpy(,name);x.attribute=attribute;x.number=dd;x.length=0;x.flag=1;x.read.dnum=x.write.dnum=dd;x.read.bnum=x.write.bnum=0;iopen(&x);}/*建立文件结束*/open_file(name,attribute)/*打开文件函数*/char *name;int attribute;{OFILE x;int dnum,bnum,last,i,d;if((d=search(name,4,&dnum,&bnum))==false){printf("文件不存在,打开操作失败/n");return(false);}fseek(fc,dnum*64L,SEEK_SET);/*读出对应目录项*/fread(buffer2,64,1,fc);if((buffer2[bnum].attribute%2==1)&& attribute==1)/*对只读文件要求写*/ {printf("文件不能写,打开失败");return(false);}strcpy(,name);x.attribute=buffer2[bnum].attribute;x.number=buffer2[bnum].address;x.read.dnum=x.write.dnum=buffer2[bnum].address;x.read.bnum=x.write.bnum=0;x.flag=attribute;if(attribute==1){while(d!='/xff')/*寻找文件末尾*/{fseek(fc, d/64*64L, SEEK_SET);fread(buffer1,64L,1,fc);/*读出dnum项所在FAT*/last=d;d=buffer1[d%64];/*读出dnum块下一块内容赋给dnum*/ }/*while*/x.write.dnum=last;/*填写写指针*/fseek(fc, last*64L, SEEK_SET);fread(buffer1,64L,1,fc);for(i=0;i<64&&buffer1[i]!='#';i++);x.write.bnum=i;x.length=(buffer2[bnum].length-1)*64+i;}iopen(&x);/*填写已打开文件表*/}close_file(name)/*关闭文件函数*/char *name;{int i,dnum,bnum;if((i=sopen(name))==-1){printf("打开的文件中没有该文件,关闭失败/n");return(false);}if(openfile.file[i].flag==1)/*写文件的追加文件结束符*/{fseek(fc,openfile.file[i].write.dnum*64L, SEEK_SET);fread(buffer1,64,1,fc);buffer1[openfile.file[i].write.bnum]='#';fseek(fc,openfile.file[i].write.dnum*64L, SEEK_SET);fwrite(buffer1,64,1,fc);fputc('#',fc);search(name,4,&dnum,&bnum);/*查找该文件目录位置*//*修改目录中的文件长度*/fseek(fc,dnum*64L, SEEK_SET);fread(buffer2,64,1,fc);buffer2[bnum].length=openfile.file[i].length/64+1;fseek(fc, dnum*64L, SEEK_SET);fwrite(buffer2,64,1,fc);}/*在已打开文件表中删除该文件的登记项*/if(openfile.length>1)copen(&openfile.file[i],&openfile.file[openfile.length-1]);openfile.length--;}delete(name)/*删除文件*/char *name;{int dnum,bnum,t;if((t=search(name,4,&dnum,&bnum))==false){printf("文件不存在/n");return(false);}if(sopen(name)!=-1){printf("该文件打开,不能删除/n");return(false);}fseek(fc,dnum*64L, SEEK_SET);fread(buffer2,64,1,fc);buffer2[bnum].name[0]='$';/*将该文件的目录置成空目录*/fseek(fc,dnum*64L, SEEK_SET);fwrite(buffer2,64,1,fc);while(t!='/xff')/*通过FAT查找每一个盘块号,并依次删除*/{dnum=t;fseek(fc, dnum/64*64, SEEK_SET);fread(buffer1,64,1,fc);t=buffer1[dnum%64];buffer1[dnum%64]=0;fseek(fc, dnum/64*64L, SEEK_SET);fwrite(buffer1,64,1,fc);}}/*文件删除结束*/md(name)/*建立目录函数,目录路径名name*/char *name;{int dnum,bnum,i,j,last,k,s,d,t,tt,b,dd,flag,dn,bn;char dname[3],pathname[20];i=2;/* i=根目录的起始盘块号*//* 将name分成两部分,目录路径pathname和目录名dname*/ for(j=0;name[j]!='/0';j++)/*查找最后一个"/"*/if(name[j]=='/')s=j;/*分离目录路径*/for(j=0;j<s;j++)pathname[j]=name[j];pathname[j]='/0';/*分离目录名*/for(k=0,j=s+1;name[j]!='/0'&&k<3&&name[j]!='.';j++,k++) dname[k]=name[j];if(k==0){printf("错误文件名或目录名/n");return(false);}for(;k<3;k++)dname[k]=' ';if((d=search(pathname,8,&dn,&bn))==false)/*找到目录路径*/{printf("目录不存在,不能建立/n");return(false);}b=-1;/*确认该目录不存在的同时查找空目录项*/fseek(fc,d*64L,SEEK_SET);fread(buffer2,64L,1,fc);/*读出d盘块的内容*/for(t=0;t<8;t++){if(buffer2[t].name[0]==dname[0]&&buffer2[t].name[1]==dname[1] &&buffer2[t].name[2]==dname[2]&&buffer2[t].attribute==8) {/*找到名字dname的目录,建立失败*/printf("目录已经存在,不能建立/n");return(false);}if(buffer2[t].name[0]=='$'&&b==-1)b=t;}/*for*/if(b==-1)/*没有空目录项,不能建立*/{printf("目录无空间/n");return(false);}if((dd=allocate( ))==false)/*分配给建立目录的磁盘盘块dd*/{printf("目录不能建立/n");return(false);}/*填写目录项*/for(i=0;i<3;i++)buffer2[b].name[i]=dname[i];buffer2[b].type[0]=buffer2[b].type[1]=' ';buffer2[b].attribute=8;buffer2[b].address=dd;buffer2[b].length=0;fseek(fc,d*64L,SEEK_SET);fwrite(buffer2,64L,1,fc);/*分给新建目录的盘块初始化*/for(t=0;t<8;t++)buffer2[t].name[0]='$';fseek(fc, dd*64L, SEEK_SET);fwrite(buffer2,64L,1,fc);}/*建立目录结束*/dir(name)/*显示目录内容*/char *name;{int i,bnum,t,tt,dnum,dn,bn;if((dnum=search(name,8,&dn,&bn))==false)/*找到目录路径,返回该目录所在块号dn和盘块内项数bn*/{printf("目录不存在/n");return(false);}printf("名称扩展名起始盘块长度/n");/*显示目录内容*/fseek(fc,dnum*64L, SEEK_SET);fread(buffer2,64L,1,fc);for(t=0;t<8;t++)/*显示该盘块中目录项的内容*/if(buffer2[t].name[0]!='$')printf(" %c%c%c %c%c %4d%7d/n", buffer2[t].name[0], buffer2[t].name[1],buffer2[t].name[2], buffer2[t].type[0], buffer2[t].type[1],buffer2[t].address, buffer2[t].length);}/*显示目录函数结束*/typefile(name)/*显示文件内容*/char *name;{int i,dnum,dn,bn,t;if((dnum=search(name,1,&dn,&bn))==false){printf("文件不存在/n");return(false);}if(sopen(name)!=-1){printf("该文件打开,不能显示/n");return(false);}while(dnum!='/xff'){fseek(fc,dnum*64L,SEEK_SET);fread(buffer1,64,1,fc);/*读一个盘块到缓冲*/for(t=0;t<64&&buffer1[t]!='#';t++)/*显示缓冲中内容*/ putchar(buffer1[t]);printf("/n");/*获得下一个盘块*/fseek(fc, dnum/64*64L, SEEK_SET);fread(buffer1,64,1,fc);dnum=buffer1[dnum%64];}}/*显示文件函数结束*/change(name,attribute)/*改变文件name的属性为attribute*/char *name;int attribute;{int dnum,bnum;if(search(name,1,&dnum,&bnum)==false)/*查找文件目录*/ {printf("文件不存在/n");return(false);}if(sopen(name)!=-1){printf("该文件打开,不能改变文件属性/n");return(false);}fseek(fc,dnum*64L,SEEK_SET);fread(buffer2,64,1,fc);/*读出该目录所在盘块*/buffer2[bnum].attribute=attribute;/*修改属性*/fseek(fc,dnum*64L,SEEK_SET);fwrite(buffer2,64,1,fc);/*写回磁盘*/}/*改变文件属性函数结束*/main( ){char name[20];int attribute,type,length,i,a,j;char buffer[64];/*建立文件,模拟磁盘*/if((fc=fopen("c://os//c","w+"))==NULL){printf("无法打开文件/n");exit(0);}/*初始化已打开文件表*/openfile.length=0;/*初始化磁盘*//*初始化文件分配表*/buffer1[0]=buffer1[1]=buffer1[2]=255;/*磁盘第0、1块存放FAT表,第2块存放跟目录*/for(i=3;i<64;i++)buffer1[i]=0;buffer1[13]=buffer1[49]=254;/*假定模拟磁盘中有两个坏盘块:第13块和49块*/fwrite(buffer1,64L,1,fc);for(i=0;i<64;i++)buffer1[i]=0;fwrite(buffer1,64L,1,fc);/*初始化根目录*/for(i=0;i<8;i++)buffer2[i].name[0]='$';/*若目录项的第一个字符为"$"表示该目录项为空*/ fwrite(buffer2,64L,1,fc);/*初始化已打开文件表*/while(1){printf("/n 0 - 结束/n");printf(" 1 - 建立文件/n");printf(" 2 - 打开文件/n");printf(" 3 - 读文件/n");printf(" 4 - 写文件/n");printf(" 5 - 关闭文件/n");printf(" 6 - 删除文件/n");printf(" 7 - 建立目录/n");printf(" 8 - 显示目录内容/n");printf(" 9 - 显示文件内容/n");printf(" 10 - 改变文件属性/n");printf(" 选择功能项(0~9):");scanf("%d",&a);switch(a){case 0: /*a=0程序结束*/fclose(fc);exit(0);case 1: /*a=1建立文件*/printf("输入文件路径名和文件属性(1-只读文件,3-只读系统文件,4-普通文件):");scanf("%s%d",name,&attribute);create_file(name,attribute); /*建立文件*/break;case 2: /*a=2打开文件*/printf("输入文件路径名和操作类型(0-读文件,1-写文件):");scanf("%s%d",name,&type);open_file(name,type); /*打开文件*/break;case 3: /*a=3读文件*/printf("输入文件路径名和读长度");scanf("%s%d",name,&length);read_file(name,length); /*读文件*/break;case 4: /*a=4写文件*/printf("输入文件路径名:");scanf("%s",name);printf("输入写的内容和和写长度");scanf("%s%d",buffer,&length);write_file(name,buffer,length); /*写文件*/break;case 5: /*a=5关闭文件*/printf("输入文件路径名");scanf("%s",name);close_file(name); /*关闭文件*/break;case 6: /*a=6删除文件*/printf("输入文件路径名");scanf("%s",name);delete(name); /*删除文件*/break;case 7: /*a=7建立目录*/printf("输入目录路径名");scanf("%s",name);md(name); /*建立目录*/break;case 8: /*a=8显示目录*/printf("输入目录路径名");scanf("%s",name);dir(name); /*显示目录*/break;case 9: /*a=9显示文件*/printf("输入文件路径名");scanf("%s",name);typefile(name); /*显示文件*/break;case 10:/* a=10改变文件属性*/printf("输入文件路径名和文件属性(1-只读文件,3-只读系统文件,4-普通文件):");scanf("%s%d",name,&attribute);change(name,attribute);}/* switch */}/* while */}/*main( )结束*/。
操作系统实验-P,V原语应用程序
![操作系统实验-P,V原语应用程序](https://img.taocdn.com/s3/m/90e6331e182e453610661ed9ad51f01dc28157ac.png)
int V(const int semid, char *PType, int len);
int P(const int semid, char *PType, int len);
int Produce(char *buf);
if (P(semid, "empty", num_of_production) < 0) {
printf("P full Operation Failed\n");
return -1;
}
printf("Producer [%d] Get [%d] position of the shop\n", getpid(),
printf(
"Producer [%d] put the production [%s] to the position of the "
"shop\n",
getpid(), buffer);
printf("(The production of the shop is )Shared Memory Content[%s]\n",
}
semctl(semid, 0, IPC_RMID);
shmdt(shmaddr);
if (shmctl(shmid, IPC_RMID, NULL) < 0) {
printf("RM Shm Failed[%d]\n", errno);
return -1;
}
return 0;
北邮操作系统进程管理实验报告及源代码
![北邮操作系统进程管理实验报告及源代码](https://img.taocdn.com/s3/m/7cfeebf0dc3383c4bb4cf7ec4afe04a1b071b0aa.png)
进程管理实验报告1. 实验目的:(1)加深对进程概念的理解, 明确进程和程序的区别;(2)进一步认识并发执行的实质;(3)分析进程争用资源的现象, 学习解决进程互斥的方法;(4)了解Linux系统中进程通信的基本原理。
2. 实验预备内容(1)阅读Linux的sched.h源码文件, 加深对进程管理概念的理解;(2)阅读Linux的fork()源码文件, 分析进程的创建过程。
3.环境说明本次实验使用的是win7下的VMWare workstation虚拟机, 安装了ubuntu系统在ubuntu系统下使用code::blocks IDE编写代码并执行程序的4.实验内容:1.进程的创建:(1)实验题目和要求:编写一段程序, 使用系统调用fork() 创建两个子进程。
当此程序运行时, 在系统中有一个父进程和两个子进程活动。
让每一个进程在屏幕上显示一个字符:父进程显示字符“a”, 子进程分别显示字符“b”和“c”。
试观察记录屏幕上的显示结果, 并分析原因。
(2)程序设计说明:参照书上的例子进行设计, 详见源代码(3)程序运行结果截图:(4)程序分析:a,b,c随机出现, 因为父进程与两个子进程之间并没有同步措施, 所以a,b,c随机打印出来, 也就是三个进程的活动次序是随机进行的, 不同的系统可能有不同的进程调度方式。
(5)源程序:#include<sys/types.h>#include<stdio.h>#include<unistd.h>int main(){pid_t pid1,pid2;if((pid1=fork())<0){printf("Fork Failed.\n");exit(-1);}else if((pid1=fork())==0)printf("b\n");else{if((pid2=fork())<0){printf("Fork Failed.\n");exit(-1);}else if((pid2=fork())==0)printf("c\n");else{wait(NULL);printf("a\n");exit(0);}}return 0;}2.进程的控制:要求一:(1)实验题目和要求:修改已经编写的程序, 将每个进程输出一个字符改为每个进程输出一句话, 再观察程序执行时屏幕上出现的现象, 并分析原因。
西安交通大学操作系统课内实验报告全解
![西安交通大学操作系统课内实验报告全解](https://img.taocdn.com/s3/m/1fee4729581b6bd97f19ea20.png)
西安交通大学实验报告——操作系统原理课内实验姓名:班级:学号:实验一用户接口实验一、实验目的1、理解并掌握面向操作命令的接口Shell,学会简单的shell编码。
2、理解操作系统调用的运行机制,掌握创建系统调用的方法。
二、实验内容1、控制台命令接口实验理解面向操作命令的接口shell和进行简单的shell编程。
该实验是通过“几种操作系统的控制台命令”、“终端处理程序”、“命令解释程序”和“Linux 操作系统的bash”来让实验者理解面向操作命令的接口shell 和进行简单的shell 编程。
●查看bash 版本。
●编写bash 脚本,统计/my 目录下c 语言文件的个数2) 系统调用实验。
2、系统调用实验理解操作系统调用的运行机制。
该实验是通过实验者对“Linux 操作系统的系统调用机制”的进一步了解来理解操作系统调用的运行机制;同时通过“自己创建一个系统调用mycall()”和“编程调用自己创建的系统调用”进一步掌握创建和调用系统调用的方法。
●编程调用一个系统调用fork(),观察结果。
●编程调用创建的系统调用foo(),观察结果。
●自己创建一个系统调用mycall(),实现功能:显示字符串到屏幕上。
●编程调用自己创建的系统调用。
三、实验准备为了使用户通过操作系统完成各项管理任务,操作系统必须为用户提供各种接口来实现人机交互。
经典的操作系统理论将操作系统的接口分为控制台命令和系统调用两种。
前者主要提供给计算机的操作人员对计算机进行各种控制;而后者则提供个程序员,使他们可以方便地使用计算机的各种资源。
四、实验步骤及结果1、控制台命令接口实验(1)查看b ash 版本操作:在s hell 提示符下输入:$echo $BASH_VERSION结果:版本是4.2.42(1)-release(2)建立bash 脚本,输出Hello word操作:在编辑器中输入以下内容#!/bin/bashecho Hello World!结果:操作:执行脚本使用指令:$./text结果:(3)编写bash 脚本:统计/my 目录下 c 语言文件的个数通过bash 脚本,可以有多种方式实现这个功能,而使用函数是其中个一个选择。
操作系统-实验四动态分区分配算法源代码最新最全
![操作系统-实验四动态分区分配算法源代码最新最全](https://img.taocdn.com/s3/m/f3aa1fb87f1922791788e816.png)
实验四操作系统-动态分区分配算法萨斯的发生的v设计程序模拟四种动态分区分配算法:首次适应算法、循环首次适应算法、最佳适应算法和最坏适应算法的工作过程。
假设内存中空闲分区个数为n,空闲分区大小分别为P l,…,P n,在动态分区分配过程中需要分配的进程个数为m (m<n),它们需要的分区大小分别为S i,…,S m,分别利用四种动态分区分配算法将m个进程放入n个空闲分区,给出进程在空闲分区中的分配情况。
程序要求如下:1)利用首次适应算法、循环首次适应算法、最佳适应算法和最坏适应算法四种动态分区分配算法模拟分区分配过程。
2)模拟四种算法的分区分配过程,给出每种算法进程在空闲分区中的分配情况。
3)输入:空闲分区个数n,空闲分区大小P i,…,P n,进程个数m, 进程需要的分区大小S i,…,S m,算法选择1-首次适应算法,2-循环首次适应算法,3-最佳适应算法,4-最坏适应算法。
4)输出:最终内存空闲分区的分配情况。
代码实现:#include<iostream>#include<fstream>#include<iomanip>using namespace std;const int MaxNumber=100;int FreePartition[MaxNumber];// 空闲分区大小int FirstPartition[MaxNumber];//1-首次适应算法int CycleFirstPartition[MaxNumber];//2-循环首次适应算法int BestPartition[MaxNumber];//3-最佳适应算法int WorstPartition[MaxNumber];//4-最坏适应算法int ProcessNeed[MaxNumber];// 进程需要的分区大小int PartitionNum,ProcessNum;char ProcessName[MaxNumber];// 进程名char ProcessPartition[MaxNumber];// 进程分配的序列int Partition[MaxNumber];char str[MaxNumber][MaxNumber];void FirstFit(int n,int m);void NextFit(int n,int m);void BestFit(int n,int m);void WorstFit(int n,int m);void Print(int n, int m);void Print2(int n, int m);//======================================================== void FirstFit(int n, int m){cout<<"选择了首次适应算法!"<<endl;cout<<endl;int i,j,k=0;for(i=0; i<n; i++){FirstPartition[i] = FreePartition[i];}for(j=0; j<m; j++){for(i=0; i<n; i++){if(ProcessNeed[j]<=FirstPartition[i]){ProcessPartition[j]=i;//str[i][k] = ProcessName[j];FirstPartition[i] = FirstPartition[i]-ProcessNeed[j]; break;}}}Print(n,m);cout<<"空间序号:"<<" ";for(i=0; i<n; i++)(cout<<T<<setw(m-1)<<"空间”<<(i+1);}cout<<endl;cout<<"分区大小:"<<" ";for(i=0; i<n; i++)(cout<<T<<setw(m)<<setiosflags(ios::left)<<FreePartition[i];}cout<<endl;cout<<"剩余分区大小:";for(i=0; i<n; i++)(cout<<"|"<<setw(m)<<setiosflags(ios::left)<<FirstPartition[i];}cout<<endl;Print2(n,m);}void NextFit(int n, int m)(cout<<"选择了循环首次适应算法!"<<endl;cout<<endl;int i,j,flag=0;for(i=0; i<n; i++)(CycleFirstPartition[i] = FreePartition[i];}for(j=0; j<m; j++)(for(i=flag; i<n; i++)(if(ProcessNeed[j]<=CycleFirstPartition[i])(ProcessPartition[j]=i;CycleFirstPartition[i] = CycleFirstPartition[i]-ProcessNeed[j];flag = i+1;if(i==n-1)(flag=O;)break;)))Print(n,m);cout«"空间序号:for(i=0; i<n; i++){cout«"|"«setw(m-1)«"空间"«(i+1);)cout«endl;cout«"分区大小:"vv"for(i=0; i<n; i++){cout«"|"«setw(m)«setiosflags(ios::left)«FreePartition[i];)cout«endl;cout«"剩余分区大小:";for(i=0; i<n; i++){cout«"|"«setw(m)«setiosflags(ios::left)«CycleFirstPartition[i];)cout«endl;Print2(n,m);)void BestFit(int n, int m){cout«"选择了最佳适应算法!"«endl;cout«endl;int i j,flag=O,temp,id=O,flag1 =0;for(i=0; i<n; i++){BestPartition[i] = FreePartition[i];)while(flag1<m){flag = 0;for(i=0; i<n; i++)Partition[i]=0;}for(i=0; i<n; i++)(if(ProcessNeed[flag1]<=BestPartition[i])(Partition[flag]=i;flag += 1;}}temp = BestPartition[Partition[0]];id = Partition]。
计算机操作系统实验指导汤小丹版源代码
![计算机操作系统实验指导汤小丹版源代码](https://img.taocdn.com/s3/m/f15fe60bce84b9d528ea81c758f5f61fb73628d6.png)
计算机操作系统实验指导汤小丹版源代码```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语言,实现了一个简单的操作系统进程调度算法模拟。
操作系统实验报告
![操作系统实验报告](https://img.taocdn.com/s3/m/171e7409de80d4d8d15a4f5f.png)
Linux操作系统课程实践二级学院:数学与计算机科学学院题目:进程通信共享内存学生姓名:石正坤专业:计算机科学与技术班别:计科本111班学号:1104402133指导老师:张广平日期:2013 年 6 月24日摘要操作系统作为信息科学,计算机软件的核心基础科学,其相关知识存在着抽象,难以理解等特点,为了使我们能更好的,系统的了解相关原理和概念,我们应该以相关Linux实验内容和适量的练习,通过上机实验和习题训练,帮助我们更好的实现理解跟加深巩固。
Linux操作系统是一个向用户开放源码的免费的类UNIX操作系统。
它为我们学习操作系统课程提供了一个看得见摸得着的范例。
对于我们正确理解,掌握操作系统的基本知识具有重要意义。
鉴于此,本操作系统课程涉及的实验均在Linux环境下进行。
学习计算机软件技术,特别是计算机操作系统技术,除了需要刻苦努力外,还需要掌握软件和操作系统的原理与设计技巧。
如何学习和掌握操作系统技术的原理与实际技巧呢?除了听课和读书之外,最好的方法就是在实践中练习。
例如,自己设计一个小型操作系统,多使用操作系统,多阅读和分析操作源代码等。
但由于我们的条件和学时有限,在理论学习过程中没有给同学们提供更多的实验机会。
基于共享内存的进程通信,通过在两个进程间创建一块共享内存,将共享内存块分为两部分,标示位和数据域。
通过实践让我们了解了什么是共享内存通信机制,实现了程序进程间的通信。
目录一、摘要 (2)二、目录....................................................................................................................... .3三、开发环境介绍....................................................................................................... .4四、课程实践须知 (5)五、课程实践题目和要求 (6)1.课程实践题目 (6)2.课程实践目的 (6)3.课程实践内容 (6)4.共享储存区的创建 (6)六、实践规划 (7)1.共享内存的函数与进程A代码 (7)2.进程B、C代码 (8)3.进程D代码 (9)4.Linux下C语言编程问题 (10)5.涉及的线程函数 (11)七、详细的课程实践 (13)1.实验原理 (13)2.实验源代码 (14)3.实验结果截图 (17)4.附录 (18)八、执行结果及分析 (22)1. 结果 (22)2.分析 (23)九、实验心得 (24)三、开发环境介绍计算机Windows Xp系统、虚拟机上运行的Red Hat Linux 9系统运行环境。
(完整word版)操作系统实验进程的通信
![(完整word版)操作系统实验进程的通信](https://img.taocdn.com/s3/m/cde3b37ee87101f69f31951a.png)
(操作系统原理和linux操作系统相结合的实验)实验二进程的通信一实验目的1 学会使用vi编辑器编辑C语言程序2 学会Linux环境下gcc的使用3 学会调试工具GDB的使用二实验原理1 利用linux提供的进程通信的系统调用设计进程通信程序,加深对进程通信概念的理解。
2 体会进程通信的方法和效果。
三实验环境PC机1台,Windows操作系统和其上的虚拟Linux操作系统。
四实验步骤1.管道通信(1)编写一个程序。
父进程创建一个子进程和一个无名管道fd,由子进程向管道写入信息“This is a message”,然后终止执行;父进程接收到子进程终止信号后从管道中读出并显示信息后结束。
#include<stdio.h>#include<unistd.h>main(){int p1,fd[2];char outpipe[50]; //定义读缓冲区char inpipe[50]="This is a message!"; //定义写缓冲区pipe(fd); //创建无名管道fdwhile((p1=fork())==-1);if (p1==0) //子进程返回{write(fd[1],inpipe,50); //写信息到管道exit(0);}else //父进程返回{wait(0); //等待子进程终止read(fd[0],outpipe,50); //从管道读信息到读缓冲区printf("%s\n",outpipe); //显示读到的信息exit(0);}}(2)父进程创建两个子进程,父子进程之间利用管道进行通信。
要求能显示父进程、子进程各自的信息,体现通信效果。
(源程序pipe_1.c)#include<stdio.h>main(){int I,r,j,k,l,p1,p2,fd[2];char buf[50],s[50];pipe(fd);while((p1=fork())==-1);if(p1==0){lockf(fd[1],1,0);sprintf(buf,"Child process p1 is sending message!\n");printf("Child process p1!\n");write(fd[1],buf,50);lockf(fd[1],0,0);sleep(5);j=getpid();k=getppid();printf("p1 %d is weakup.My parent process id is %d.\n",j,k);exit(0);}else{while((p2=fork())==-1);if(p2==0){lockf(fd[1],1,0);sprintf(buf,"Child process p2 is sending message!\n");printf("Child process p2!\n");write(fd[1],buf,50);lockf(fd[1],0,0);sleep(5);j=getpid();k=getppid();printf("p2 %d is weakup.My parent process id is %d.\n",j,k);exit(0);}else{I=getpid();wait(0);if(r=read(fd[0],s,50)==-1)printf("can’t read pip e.");elseprintf("Parent %d:%s\n",l,s);wait(0);if(r=read(fd[0],s,50)==-1)pr intf("can’t read pipe");elseprintf ( "Parent %d:%s\n",l,s);exit(0);}}}结果:2.共享内存通信。
计算机操作系统实验指导linux版王红玲源码
![计算机操作系统实验指导linux版王红玲源码](https://img.taocdn.com/s3/m/7cf2a12658eef8c75fbfc77da26925c52cc5919d.png)
计算机操作系统实验指导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内核源代码中与内存管理和文件系统相关的部分,并完成一系列与之相关的实验任务。
任务包括实现内存分配算法、设计和实现文件系统、调试和优化内存和文件系统的性能等。
数据结构大型实验大整数运算系统附源代码
![数据结构大型实验大整数运算系统附源代码](https://img.taocdn.com/s3/m/585aa2deeefdc8d377ee326e.png)
数据构造大型实验实验报告〔附源代码〕工业大学朱镇洋耀明华族目录第一局部要求与概述一、实验目的以及准备1.1.1 问题描述. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .1.1.2 根本要求. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .1.1.3 设计思路. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .第二局部具体实现一、代码局部2.1.1 链表类及大数类的局部说明以及局部源码. . . . . . . . . . . . . . . . . . . . . . . . . . . . .2.1.2 局部简单函数功能. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .2.1.3 加法. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .2.1.4 减法. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .2.1.5 乘法. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .2.1.6 除法. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .2.1.7 幂运算. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .2.1.8 二进制和十进制的相互转化. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .二、程序流程及函数间关系2.2.1 程序流程图. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .2.2.2 函数调用关系分析. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .三、实验验证分析2.3.1 输入的形式和输入值的围. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .2.3.2 输出的形式. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .2.3.3 程序所能到达的功能. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .2.3.4 测试数据. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .四、调试分析2.4.1 调试过程中的主要技术问题以及具体的解决方法. . . . . . . . . . . . . . . . . . . . . . . .2.4.2 印象最深刻的3个调试错误,及修正方法. . . . . . . . . . . . . . . . . . . . . . . . . . . . . .五、附录2.5.1 源代码及其所属文件. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .第一局部要求与概述1.1.1 问题描述•密码学分为两类密码:对称密码和非对称密码。
- 1、下载文档前请自行甄别文档内容的完整性,平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益,请联系客服反馈,我们会尽快为您处理(人工客服工作时间:9:00-18:30)。
ready=p;
}
else /*进程比较优先级,插入适当的位置中*/
{
first=ready;
second=first->link;
while(second!=NULL)
{
if((p->super)>(second->super)) /*若插入进程比当前进程优先数大,*/
typedef struct pcb PCB;
sort() /*建立对进程进行优先级排列函数*/
{
PCB *first, *second;
int insert=0;
if((ready==NULL)||((p->super)>(ready->super))) /*优先级最大者,插入队首*/
{
p->link=ready;
三.实验运行环境及上机前的准备
实验运行环境: C语言编程环境
上机前的准备工作包括:
按实验指导书要求事先编好程序;
准备好需要输入的中间数据;
估计可能出现的问题;
预计可能得到的运行结果。
四.实验内容及安排
实验内容包括进程调度、银行家算法、页式地址重定位模拟,LRU算法模拟和先来先服务算法五个实验。每个实验介绍了实习的目的要求、内容和方法。
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';
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函数*/
#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*/
操作系统
—.课程的性质、目的和任务
操作系统在整个计算机系统软件中占有中心地位。其作用是对计算机系统进行统一的调度和管理,提供各种强有力的系统服务,为用户创造既灵活又方便的使用环境。本课程是计算机及应用专业的一门专业主干课和必修课。通过本课程的学习,使学生掌握操作系统的基本概念、设计原理及实施技术,具有分析操作系统和设计、实现、开发实际操作系统的能力。
{
int 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);
二.实验的意义和目的
操作系统是计算机专业学生的一门重要的专业课程。操作系统质量对整个计算机系统的性能和用户对计算机的使用有重大的影响。一个优良的操作系统能极大地扩充计算机系统的功能,充分发挥系统中各种设备的使用效率,提高系统工作的可靠性。由于操作系统涉及计算机系统中各种软硬件资源的管理,内容比较繁琐,具有很强的实践性。要学好这门课程,必须把理论与实践紧密结合,才能取得较好的学习效果。培养计算机专业的学生的系统程序设计能力,是操作系统课程的一个非常重要的环节。通过操作系统上机实验,可以培养学生程序设计的方法和技巧,提高学生编制清晰、合理、可读性好的系统程序的能力,加深对操作系统课程的理解。使学生更好地掌握操作系统的基本概念、基本原理、及基本功能,具有分析实际操作系统、设计、构造和开发现代操作系统的基本能力。
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))
ready=p;
}
else /*进程比较优先级,插入适当的位置中*/
{
first=ready;
second=first->link;
while(second!=NULL)
{
if((p->super)>(second->super)) /*若插入进程比当前进程优先数大,*/
{ /*插入到当前进程前面*/
实
[目的要求]
用高级语言编写和调试一个进程调度程序,以加深对进程的概念及进程调度算法的理解.
[准备知识]
一、基本概念
1、进程的概念;
2、进程的状态和进程控制块;
3、进程调度算法;
二、进程调度
1、进程的状态
2、进程的结构——PCB
进程都是由一系列操作(动作)所组成,通过这些操作来完成其任务。因此,不同的进程,其内部操作也不相同。在操作系统中,描述一个进程除了需要程序和私有数据之外,最主要的是需要一个与动态过程相联系的数据结构,该数据结构用来描述进程的外部特性(名字、状态等)以及与其它进程的联系(通信关系)等信息,该数据结构称为进程控制块(PCB,ProcessControlBlock)。
{
printf("\n qname \t state \t super \t ndtime \t runtime \n");
printf("|%s\t",pr->name);
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) /*建立进程显示函数,用于显示当前进程*/
进程控制块PCB与进程一一对应,PCB中记录了系统所需的全部信息、用于描述进程情况所需的全部信息和控制进程运行所需的全部信息。因此,系统可以通过进程的PCB来对进程进行管理。
[试验内容]
设计一个有N个进程共行的进程调度程序。
进程调度算法:采用最高优先数优先的调度算法(即把处理机分配给优先数最高的进程)和先来先服务算法。每个进程有一个进程控制块(PCB)表示。进程控制块可以包含如下信息:进程名、优先数、到达时间、需要运行时间、已用CPU时间、进程状态等等。进程的优先数及需要的运行时间可以事先人为地指定(也可以由随机数产生)。进程的到达时间为进程输入的时间。进程的运行时间以时间片为单位进行计算。每个进程的状态可以是就绪W(Wait)、运行R(Run)、或完成F(Finish)三种状态之一。就绪进程获得CPU后都只能运行一个时间片。用已占用CPU时间加1来表示。如果运行一个时间片后,进程的已占用CPU时间已达到所需要的运行时间,则撤消该进程,如果运行一个时间片后进程的已占用CPU时间还未达所需要的运行时间,也就是进程还需要继续运行,此时应将进程的优先数减1(即降低一级),然后把它插入就绪队列等待CPU。每进行一次调度程序都打印一次运行进程、就绪队列、以及各个进程的PCB,以便进行检查。
重复以上过程,直到所要进程都完成为止。
调度算法的流程图如下:
进程调度源程序如下:
jingchendiaodu.cpp
#include "stdio.h"
#include <stdlib.h>
#include <conio.h>
#define getpch(type) (type*)malloc(sizeof(type))
}
}
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("\n\n进程已经完成.\n");