模拟进程管理

合集下载

用C语言模拟实现操作系统的进程管理机制

用C语言模拟实现操作系统的进程管理机制

《操作系统》实验报告实验一题目用C语言模拟实现操作系统的进程管理机制一、实验内容使用顺序表模拟内存中的进程队列,实现对于进程的管理。

进程的管理主要包括进程的创建、进程的查询、进程的换出以及进程的删除等操作。

二、实验目的进程是计算机操作系统的重要的核心概念,合理的管理进程是一个操作系统最核心主要的功能之一,通过编写相应的进程程序,加强对进程概念的理解。

三、设计过程1进程结构PCB的描述:typedef struct jincheng_type{int pid;int priority;char state;int blocktime;}PCB;PCB是对进程的描述,pid代表进程号,priority代表优先级,state代表状态,blocktime代表阻塞时间。

2进程队列的描述:使用顺序表typedef struct queuelist{PCB pro[MAXSIZE];int length;}MEMORY;内存的描述,系统创建的进程都保存在这里,MAXSIZE是内存中允许存放最大的进程数目3本实验主要包含如下三个主要操作(1)创建进程操作void create(MEMORY *P,int count);参数P是指向存放进程的内存指针(头指针),count是指创建进程的数目。

(2)查询进程操作int check(MEMORY *P,int pid);参数P是指向存放进程的内存指针(头指针),pid是指查询进程的进程号,若查询到该进程则返回OK(1),否则返回ERROR(0)。

(3)置换进程操作int exchange(MEMORY *P);参数P是指向存放进程的内存指针(头指针),将换出的进程保存在PCB pcb;中,若换出某个进程则返回OK(1),否则返回ERROR(0)。

(4)删除进程操作int kill(MEMORY *P,int i);参数P是指向存放进程的内存指针(头指针),删除内存中第i个进程,若删除某个进程则返回OK (1),否则返回ERROR (0)。

进程管理模拟实验

进程管理模拟实验

进程管理一、目的与要求1.目的进程是操作系统最重要的概念之一,是了解操作系统实质的关键。

本课题实习的目的是,加深对进程概念及进程管理各部分内容的理解;熟悉进程管理中主要数据结构的设计及进程调度算法、进程控制机构、同步机构、通讯机构的实施。

2.要求要求设计一个允许n个进程并发运行的进程管理模拟系统。

该系统包括以下内容:(1)简单的进程控制(2)同步及通讯机构(3)中断机构(4)进程调度。

其进程调度算法可任意选择。

每个进程用一个PCB表示,其内容可根据具体情况设置。

各进程之间有一定的同步关系。

系统在运行过程中应能显示或打印各进程的状态及有关参数的变化情况,以便观察诸进程的运行过程及系统的管理过程。

二、范例1.题目支持多个进程并发运行的简单进程管理模拟系统本系统的同步机构采用信号量上的P、V操作的机制;控制机构包括阻塞和唤醒操作;时间片中断处理程序模拟时间片中断;进程调度程序负责为各进程分配处理机。

系统中涉及了3个并发进程。

它们之间的关系是:3个进程需要互斥使用临界资源S2,进程1和进程2又需互斥使用临界资源S1.本系统在运行过程中随机打印出各进程的状态变换过程,系统的调度过程及公共变量的变化情况。

2.算法与N~S图系统为进程设置了5种运行状态:e—执行态;r—高就绪态;t—低就绪态(执行进程因时间片到限而转入);w—等待态;c—完成态。

各进程的初始状态均设置为r.系统分时执行各进程,并规定3个进程的执行概率均为33%。

通过产生随机数x来模拟时间片。

当进程process1访问随机数x时,若x>=0.33;当进程process2访问x时,若x<0.33或x>=0.66;当进程process3访问x时,若x<0.66,则分别认为各进程的执行时间片到限,产生“时间片中断”而转入低就绪态t。

进程调度算法采用剥夺式最高优先数法。

各进程的优先数通过键盘输入予以静态设置。

调度程序每次总是选择优先数最小(优先权最高)的就绪进程投入执行。

进程管理模拟系统课程设计

进程管理模拟系统课程设计

进程管理模拟系统课程设计一、课程目标知识目标:1. 学生能理解进程管理的基本概念,掌握进程的创建、同步、通信及调度等原理;2. 学生能运用所学知识分析进程管理模拟系统的运作过程,理解操作系统的进程管理功能;3. 学生了解进程管理在计算机系统中的应用,明确其在操作系统中的重要性。

技能目标:1. 学生能够独立设计简单的进程管理模拟系统,具备实际操作能力;2. 学生通过实践,提高程序设计能力,学会使用相关工具分析进程管理问题;3. 学生学会运用进程同步和通信技术解决实际问题,培养解决问题的能力。

情感态度价值观目标:1. 学生通过学习进程管理,培养团队合作精神,增强沟通与协作能力;2. 学生在学习过程中,培养严谨、细致的科学态度,提高对操作系统的兴趣;3. 学生认识到操作系统在计算机系统中的核心地位,增强学习操作系统的自觉性和责任感。

本课程旨在帮助学生掌握进程管理的核心知识,培养实际操作和解决问题的能力,同时注重培养学生的团队协作和情感态度,使他们在学习过程中形成正确的价值观。

课程针对学生的年级特点,注重理论与实践相结合,以操作系统的进程管理为基础,引导学生运用所学知识解决实际问题。

在教学过程中,教师需关注学生的学习进度,及时调整教学策略,确保课程目标的实现。

二、教学内容1. 进程管理基本概念:进程与线程的定义、进程的状态与转换、进程控制块(PCB)的作用;2. 进程同步与互斥:同步机制、互斥锁、生产者-消费者问题、读者-写者问题;3. 进程通信:管道、消息队列、信号量、共享内存;4. 进程调度:调度算法(如FCFS、SJF、RR等)、调度策略、调度性能分析;5. 进程管理模拟系统设计:系统架构、模块划分、关键算法实现;6. 实践操作:使用相关工具(如Linux系统调用、C语言编程等)设计并实现一个简单的进程管理模拟系统。

教学内容根据课程目标进行组织,以教材中关于进程管理的章节为基础,结合学生实际情况进行合理安排。

计算机操作系统 模拟进程管理

计算机操作系统 模拟进程管理

#include "windows.h"#include "stdio.h"#include "dos.h"#include "stdlib.h"#include "conio.h"#define SEC 3000 //睡眠时间(ms) #define NULL 0/*定义结构体*/typedef struct PCB{int PID;int UID;struct PCB * next;}PCB;PCB *ready , *excute , *wait;/*create queue header *//*queue operation 入队*/int enqueue(PCB *head , PCB *node){PCB *p;p = head;if(p -> next == NULL){head -> next = node;return 1;}while(p){if(p -> next == NULL){p -> next = node;return 1;}else p = p -> next;}}/*enquue*//*dequeue 出队列*/PCB * dequeue(PCB *head){PCB *p;p = head;if(p -> next == NULL){return NULL;}else{p = p -> next;head -> next = p -> next;p -> next = NULL;return p;}/*head to next*/}/*dequeue*//*PCB operate*//*新建进程*/int create(){PCB *p;p = (PCB*)malloc(sizeof(PCB));p -> next = NULL;printf("input PID and UID to a new process\n");scanf("%d %d",&p -> PID,&p -> UID);if(enqueue(ready , p))printf("create a process: PID = %d UID = %d\n", p -> PID , p -> UID);elseprintf("create Failed\n");return(0);}/*create*//*将就绪队列的先到进程加入到运行队列中fexcute*/int fexcute(){PCB *p = dequeue(ready);if(p == NULL){printf("NO process in queue \n");return 0;}else{enqueue(excute , p);printf("add a process into excute queue process: PID = %d UID= %d \n" ,p->PID , p->UID); return 1;}}/*excute*///挂起正在运行的进程int suspend(){PCB *p = dequeue(excute);if(p == NULL){printf("NO process in queue \n");return 0;}else{enqueue(ready , p);printf("add a process into ready queue process: PID = %d UID= %d \n" ,p->PID , p->UID); return 1;}}//唤醒等待队列中的进程int wake(){PCB *p = dequeue(wait);if(p == NULL){printf("NO process in queue \n");return 0;}else{enqueue(ready , p);printf("add a process into wait ready process: PID = %d UID= %d \n" ,p->PID , p->UID); return 1;}}//阻塞运行队列中的进程int block(){PCB *p = dequeue(excute);if(p == NULL){printf("NO process in queue \n");return 0;}else{enqueue(wait , p);printf("add a process into wait queue process: PID = %d UID= %d \n" ,p->PID , p->UID); return 1;}}/*block*//*输出队列outputqueue*/int outputqueue(PCB *head){PCB *p;if(head -> next == NULL){/*队列为空*/printf("queue is null \n");return 1;}p = head -> next; /*node pointer*/while(p){/*打印process id UID*/printf("PID = %d UID = %d \n" , p -> PID , p -> UID);p = p -> next;}return 0;}/*output输出*/int output(){printf("READY QUEUE:\n");outputqueue(ready);printf("EXCUTE QUEUE: \n");outputqueue(excute);printf("WAIT QUEUE: \n");outputqueue(wait);return(0);}/*output*//*init 初始化*/int init(){PCB *p;ready = (PCB*)malloc(sizeof(PCB));ready -> next=NULL;excute = (PCB*)malloc(sizeof(PCB));excute -> next=NULL;wait = (PCB*)malloc(sizeof(PCB));wait -> next = NULL;printf("____________PROCESS SECHUDLE__________\n"); printf("now initing.....................\n");printf("input PID and UID as integer , 0 0 as over\n"); while(1){p = (PCB*)malloc(sizeof(PCB));p -> next = NULL;scanf("%d %d",&p -> PID , &p -> UID);if(p -> PID == 0 && p -> UID == 0)break;else{if(enqueue(ready , p)){printf("new process PID = %d UID = %d added!\n",p -> PID , p -> UID);}else return 0;}}return 1;}/*init*//*运行一个process 并释放节点*/int run(){PCB *p = excute;int s = SEC;if(excute -> next == NULL){printf("no process in excute queue \n");return 0;}else{p = excute -> next;printf("system will sleep %ds as process running\n",s);Sleep(s);/*sleep as process runing time*/printf("process: PID = %d UID= %d excute successed..\n" , p -> PID , p -> UID ); excute -> next = p -> next;free(p);}}/*run*//*离开*/int leave(){PCB *p,*t;while(ready->next || excute->next || wait->next){p = ready -> next;{t = p -> next;free(p);p = t;}ready -> next = NULL;p = wait -> next;while(p){t = p -> next;free(p);p = t;}wait -> next = NULL;p = excute -> next;while(p){t = p -> next;free(p);p = t;}excute -> next = NULL;}exit(0);}/*leace*///帮助菜单int help(){printf("_____________________HELP MENU_____________________\n"); printf("\t-h HELP 弹出帮助菜单\n");printf("\t-c CREATE 创建一个新进程,并加入到就绪队列中\n");printf("\t-b BLOCK 阻塞正在运行的进程\n");printf("\t-w WAKE 唤醒等待队列中的进程\n");printf("\t-e EXCUTE 运行就绪队列中的进程\n");printf("\t-s SUSPEND 挂起正在运行的进程\n");printf("\t-o OUTPUT 输出所有进程队列\n");printf("\t-r RUN 运行运行队列中的进程\n");printf("\t-x EXIT 释放内存并退出程序\n");printf("___________________________________________________\n"); printf("\t 输入‘h/H’弹出帮助菜单\n");return(0);}/*help*///zhu{char COMMAND = NULL;if( init() != 1){printf("init falied ! \n ");getch();exit(0);}else{printf("init...OK\n");output();help();}while(1){/*当三队列都不空执行调度*/ printf(">");scanf("%c",&COMMAND); switch(COMMAND){case '\n': break;case 'H':case 'h': help(); break;case 'C':case 'c': create(); break;case 'B':case 'b': block(); break;case 'W':case 'w': wake(); break;case 'S':case 's': suspend(); break;case 'E':case 'e': fexcute(); break;case 'O':case 'o': output(); break;case 'X':case 'x': leave(); break;case 'R':case 'r': run(); break;}}}/*main*/。

模拟进程管理课程设计c

模拟进程管理课程设计c

模拟进程管理课程设计c一、教学目标本课程的学习目标包括知识目标、技能目标和情感态度价值观目标。

知识目标要求学生掌握进程管理的基本概念、原理和方法。

技能目标要求学生能够运用进程管理知识分析和解决实际问题。

情感态度价值观目标要求学生培养对进程管理的兴趣和热情,提高自主学习的能力。

通过本课程的学习,学生将了解进程的定义、特点和分类,掌握进程管理的基本原理和方法,能够运用进程管理知识分析和解决实际问题。

同时,学生将培养对进程管理的兴趣和热情,提高自主学习的能力。

二、教学内容本课程的教学内容主要包括进程管理的基本概念、进程的描述与控制、进程的同步与互斥、进程的通信与同步、进程调度和死锁处理。

具体的教学大纲安排如下:第1周:进程管理的基本概念、进程的描述与控制;第2周:进程的同步与互斥、进程的通信与同步;第3周:进程调度、死锁处理;第4周:课程总结与复习。

三、教学方法为了激发学生的学习兴趣和主动性,本课程将采用多种教学方法,包括讲授法、讨论法、案例分析法和实验法等。

在讲授法的基础上,教师将引导学生进行思考和讨论,通过案例分析法和实验法,使学生能够将理论知识应用于实际问题中,提高分析和解决实际问题的能力。

四、教学资源为了支持教学内容和教学方法的实施,丰富学生的学习体验,我们将选择和准备适当的教学资源。

教材:《进程管理>();参考书:《现代操作系统>();多媒体资料:相关教学视频、PPT课件;实验设备:计算机、网络设备等。

以上教学资源将帮助学生更好地理解和掌握进程管理知识,提高学习效果。

五、教学评估本课程的评估方式将包括平时表现、作业和考试等。

评估方式应客观、公正,能够全面反映学生的学习成果。

平时表现将根据学生在课堂上的参与度、提问和回答问题的表现进行评估。

作业将根据学生提交的作业质量和及时性进行评估。

考试将包括期中考试和期末考试,考试内容将涵盖课程的全部内容,采用客观题和主观题相结合的方式。

通过以上评估方式,我们将全面了解学生的学习成果,及时发现问题并进行调整,提高教学质量。

模拟进程管理(c语言)

模拟进程管理(c语言)

0128 #include "stdafx.h"#include "stdio.h"#include "stdlib.h"#include "string.h"typedef struct node{char name[10]; /*進程標識符*/int prio; /*進程優先數*/int round; /*進程時間輪轉時間片*/int cputime; /*進程占用CPU時間*/int needtime; /*進程到完成還要の時間*/int count; /*計數器*/char state; /*進程の狀態*/struct node *next; /*鏈指針*/}PCB;PCB *finish,*ready,*tail,*run; /*隊列指針*/int N; /*進程數*//*將就緒隊列中の第一個進程投入運行*/firstin(){run=ready; /*就緒隊列頭指針賦值給運行頭指針*/run->state='R'; /*進程狀態變為運行態*/ready=ready->next; /*就緒對列頭指針後移到下一進程*/}/*標題輸出函數*/void prt1(char a){if(toupper(a)=='P') /*優先數法*/printf(" 進程號cpu時間所需時間優先數狀態\n");elseprintf(" 進程號cpu時間所需時間記數時間片狀態\n");}/*進程PCB輸出*/void prt2(char a,PCB *q){if(toupper(a)=='P') /*優先數法の輸出*/printf(" %-10s%-10d%-10d%-10d %c\n",q->name,q->cputime,q->needtime,q->prio,q->state);else/*輪轉法の輸出*/printf(" %-10s%-10d%-10d%-10d%-10d %-c\n",q->name,q->cputime,q->needtime,q->count,q->round,q->state);}/*輸出函數*/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;}getchar(); /*壓任意鍵繼續*/}/*優先數の插入算法*/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;}elseb=0;if(r!=p1) /*如果條件成立說明插入在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;}}//clrscr();printf(" 優先數算法輸出信息:\n");printf("************************************************\n");prt(alg); /*輸出進程PCB信息*/run=ready; /*將就緒隊列の第一個進程投入運行*/ready=ready->next;run->state='R';}/*優先數調度算法*/priority(char alg){while(run!=NULL) /*當運行隊列不空時,有進程正在運行*/{run->cputime=run->cputime+1;run->needtime=run->needtime-1;run->prio=run->prio-3; /*每運行一次優先數降低3個單位*/if(run->needtime==0) /*如所需時間為0將其插入完成隊列*/{run->next=finish;finish=run;run->state='F'; /*置狀態為完成態*/run=NULL; /*運行隊列頭指針為空*/if(ready!=NULL) /*如就緒隊列不空*/firstin(); /*將就緒對列の第一個進程投入運行*/}else /*沒有運行完同時優先數不是最大,則將其變為就緒態插入到就緒隊列*/ if((ready!=NULL)&&(run->prio<ready->prio)){run->state='W';insert1(run);firstin(); /*將就緒隊列の第一個進程投入運行*/}prt(alg); /*輸出進程PCB信息*/}}/*主函數*/main(){char algo; /*算法標記*///clrscr();//printf("選擇算法:P/R(優先數算法/時間片輪轉算法)\n");//scanf("%c",&algo); /*輸入字符確定算法*/algo='p';printf("輸入進程數:\n");scanf("%d",&N); /*輸入進程數*/if(algo=='P'||algo=='p'){create1(algo); /*優先數法*/priority(algo);}elseif(algo=='R'||algo=='r'){//create2(algo); /*輪轉法*///roundrun(algo);} }。

进程管理模拟实验指导书09

进程管理模拟实验指导书09

进程管理模拟系统实验指导书2一、实验目的学习进程管理的设计与实现,学习和运用操作系统原理,设计一个操作系统子系统的模拟系统。

通过该系统的设计调试可增加对操作系统实现的感知性。

同时可发挥团队协作精神和个人创造能力。

使同学们对操作系统学习有一个实现的尝试和创新的思维。

二、实验规则1.每组设计一个模拟系统(共100分)2.每人设计系统中的一部分(满分60分)3.集体调试创意(满分40分)三、实验要求1.进程管理功能以进程调度为主要功能。

以进程控制为辅助功能。

2.体现操作系统原理中进程调度算法和进程控制算法。

按照操作系统原理设计。

3.结构化设计。

设计时构建出模块结构图并存于文件中。

模块化实现,对每一功能,每一操作使用模块、函数、子程序设计方法实现。

4.进程以PCB为代表。

队列、指针用图示。

每一步功能在桌面上能显示出来。

5.系统应具有排错功能,对可能出现的错误应具有排查功能和纠错能力。

6.界面自行设计,语言自行选择。

(可用VC/C++/C/C#语言,也可用你会的其他语言,甚至还可用PPT)7.每人的设计功能都能表现或说明出来。

8.进程以队列法组织,对不同进程调度算法:FIFO队列或PRI队列或rotate(轮转队列)用同一个进程序列组织,对阻塞队列可设置一个,也可设多个。

9.因为是模拟系统,所以要显示每个功能和操作结果。

显示应力求清晰、易读和一目了然(一屏),最好能用汉字,否则可用英语或汉语拼音。

10.操作方便,使用便捷。

可视化程度高。

11.设计出系统后,还需要写出(介绍系统采用的语言、支撑平台、小组成员及分工。

如何安装、如何启动、如何操作)12.每组需写一份课程设计报告,内容包括:课程设计内容,课程设计设计思路,课程设计结构图,及分工内容、介绍。

13. 实验结果演示验收后,将可在任何环境下运行的可执行文件和系统说明书一起存盘并交盘。

(可合组一张盘),上标:班级、组号、姓名。

14. 实验结束后从中选出优秀作品,介绍给大家。

进程的管理实验报告结论

进程的管理实验报告结论

一、实验背景及目的进程是操作系统中基本的活动单位,进程管理是操作系统核心功能之一。

为了深入理解进程的概念、进程状态转换、进程同步与互斥等知识,我们进行了进程管理实验。

本次实验旨在通过编写程序,模拟进程的创建、调度、同步与互斥等操作,加深对进程管理的理解。

二、实验内容及方法1. 进程创建与状态转换(1)使用系统调用fork()创建子进程,观察父进程和子进程的状态转换过程。

(2)使用系统调用exec()替换子进程的内容,观察子进程状态变化。

2. 进程调度(1)编写进程调度程序,实现最高优先数优先调度算法和先来先服务调度算法。

(2)模拟进程就绪队列,观察调度算法对进程执行顺序的影响。

3. 进程同步与互斥(1)使用信号量实现进程同步,观察进程同步效果。

(2)使用互斥锁实现进程互斥,观察进程互斥效果。

4. 进程通信(1)使用管道实现进程间通信,观察通信效果。

(2)使用共享内存实现进程间通信,观察通信效果。

三、实验结果与分析1. 进程创建与状态转换实验结果显示,使用fork()创建子进程后,父进程和子进程的状态均为运行态。

当父进程调用exec()替换子进程内容后,子进程状态变为僵尸态,父进程状态变为运行态。

这说明进程在创建和替换过程中,其状态发生了相应的变化。

2. 进程调度实验结果显示,最高优先数优先调度算法和先来先服务调度算法均能正确执行。

最高优先数优先调度算法下,优先级高的进程先执行;先来先服务调度算法下,先到达的进程先执行。

这说明两种调度算法均能实现进程的合理调度。

3. 进程同步与互斥实验结果显示,使用信号量实现进程同步时,进程能正确地按照规定的顺序执行;使用互斥锁实现进程互斥时,进程能正确地实现互斥访问共享资源。

这说明信号量和互斥锁在进程同步与互斥方面具有重要作用。

4. 进程通信实验结果显示,使用管道实现进程间通信时,进程能正确地接收和发送数据;使用共享内存实现进程间通信时,进程能正确地访问共享内存中的数据。

操作系统实验(模拟进程管理)

操作系统实验(模拟进程管理)

操作系统实验————(1)模拟进程管理专业:信息管理与信息系统班级:信管082姓名:温静实验一进程管理1.目的和要求通过实验理解进程的概念,进程的组成(PCB结构),进程的并发执行和操作系统进行进程管理的相关原语(主要是进程的创建、执行、撤消)。

2.实验内容用C语言编程模拟进程管理,至少要有:创建新的进程;查看运行进程;换出某个进程;杀死运行进程以及进程之间通信等功能。

3.主体程序#include <conio.h>#include <stdio.h>#include <stdlib.h>struct PCB_type{ int pid;int priority;int cputime;int state;int shumu=0,pid_l;struct PCB_type neicun[20];struct PCB_type hc[10];int max=0;int number=0;void create();void run();void huanchu();void kill();/* 创建新进程*/void create(){if(shumu>=20){printf("\n内存已满,请先结束或换出进程\n");}else{shumu++;printf("\n请输入新进程的程序名\n");scanf("%d",&neicun[shumu-1].pid);printf("\n请输入新进程的优先级\n");scanf("%d",&neicun[shumu-1].priority);printf("\n请输入新进程的运行时间\n");scanf("%d",&neicun[shumu-1].cputime);printf("\n创建进程时令其状态为就绪\n");neicun[shumu-1].state=2;}printf("\n创建进程成功!\n");}/* 查看当前运行进程*/void run(){int max=0;for(int i=0;i<shumu;i++){if((neicun[i].state==1)&&(neicun[i].priority>=neicun[max].priority)) max=i;}neicun[max].state=3;printf("当前运行进程程序名:\n%d",neicun[max].pid);printf("\n该进程的优先级:\n%d",neicun[max].priority);printf("\n该进程的运行时间:\n%d",neicun[max].cputime);printf("\n该进程的状态:\n%d",neicun[max].state);}/* 换出*/void huanchu(){int k;printf("请输入要换出程序的程序名:");scanf("%d",&k);for(int j=0;j<shumu;j++){if(neicun[j].state==1){hc[number].pid=neicun[j].pid;hc[number].state=neicun[j].state;hc[number].priority=neicun[j].priority;hc[number].cputime=neicun[j].cputime;number++;neicun[j].pid=0;neicun[j].state=0;neicun[j].priority=0;neicun[j].cputime=0;pid_1++;}else printf("进程%d无法换出的pid:%d\n",j.neicun[j].pid);if(number!=0)for(int i=0;i<number;i++){printf("当前运行进程程序名:\n%d",hc[i].pid);printf("\n该进程的优先级:\n%d",hc[i].priority);printf("\n该进程的运行时间:\n%d",hc[i].cputime);printf("\n该进程的状态:\n%d",hc[i].state);}}PCB_type temp=neicun[0];for(k=0;k<=shumu;k++){if(neicun[k].priority>temp.priority)tmpe=neicun[k];}neicun[k].state=1;}/* 杀死进程*/void kill(){neicun[max].pid=0;neicun[max].priority=0;neicun[max].cputime=0;neicun[max].state=0;if(max==(shumu-1))shumu--;else{for(int j=max+1;j<shumu;j++){neicun[j-1].pid=neicun[j].pid;neicun[j-1].priority=neicun[j].priority;neicun[j-1].cputime=neicun[j].cputime;neicun[j-1].state=neicun[j].state;}shumu--;}max=0;run();}/* int k=0;printf("请输入要杀死程序的进程名:");scanf("%d",&k);if(neicun[k].state=1)neicun[k].state=2;neicun[k].cputime=0;neicun[k].pid=0;neicun[k].priority=0;neicun[k].state=0;if(k==(shumu-1))shumu--;else{for(int j=k+1;j<shumu;j++){neicun[j-1].pid=neicun[j].pid;neicun[j-1].priority=neicun[j].priority;neicun[j-1].cputime=neicun[j].cputime;neicun[j-1].state=neicun[j].state;}shumu--;}printf("进程%d已被杀死!,k");}*/int main(){int n,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.退出系统");printf("\n**********************************************");printf("\n请选择(1~5):");scanf("%d",&a);switch(a){ case 1:create( );printf("\npress anykey to go on~");getch();break;case 2 :run();printf("\npress anykey to go on~");getch();break;case 3 :huanchu();printf("\npress anykey to go on~");getch();break;case 4 :kill();printf("\npress anykey to go on~");getch();break;case 5 :exit(0);default:n=0;break;}}}5.感想与心得体会做了两周的实验,问了很多同学,可程序还是有很多问题。

进程管理模拟实验报告

进程管理模拟实验报告

实验三进程管理模拟实验关键问题:阅读后面的C语言实例,修改程序,使其优先数在运行期间可以变化(动态优先数)。

例如当某进程被时间片中断次数增加到一定数目时,提高其优先权。

设计思路:首先在进程控制块中增加一个记录进程被中断的次数的整形变量sum;然后在初始化函数中对它初始化赋值为0;然后在block()函数中在每个进程被中断后sum进行加1操作,再显示该被中断进程被中断的次数;然后再find()函数中设计当某个进程被中断的次数达到3时修改该进程的优先权,并把该优先权设计为最高!然后再由find()函数返回被选中的进程的进程号!然后通过原来的相关代码来执行它相应的操作(其他部分代码不用变动)!实现的关键代码://在3个进程中按就绪状态及其优先数选出进程。

返回选出的进程号。

int find(){int j,pd=NIL,w=MAXPRI;for (j=0;j<3;j++) //选择高就绪状态优先级最高的进程{if(pcb[j].sum==3){pcb[j].priority=0;pcb[j].sum=0;printf("《进程%d中断次数达到3次,该进程优先权最高》\n",j+1);w=pcb[j].priority;pd=j;}else{if ((pcb[j].status=='r') && (pcb[j].priority<w)){w=pcb[j].priority;pd=j;}}}if (pd==NIL) //没有高就绪状态的进程,寻找低就绪状态的进程。

{for (j=0;j<3;j++){if(pcb[j].sum==3){pcb[j].priority=0;pcb[j].sum=0;printf("《进程%d中断次数达到3次,该进程优先权最高》\n",j+1);w=pcb[j].priority;pd=j;}else{if ((pcb[j].status=='t') && (pcb[j].priority<w)){w=pcb[j].priority;pd=j;}}}}return (pd);}程序运行结果:总结及进一步改善建议:该实验综合用了进程调度,进程控制,进程同步,进程调度算法等相应知识。

模拟进程管理课程设计

模拟进程管理课程设计

模拟进程管理课程设计一、课程目标知识目标:1. 学生能理解计算机操作系统中进程管理的基本概念,掌握进程的定义、状态及其转换过程。

2. 学生能描述进程调度算法的类型及其特点,解释不同调度算法对系统性能的影响。

3. 学生能解释进程同步与互斥的概念,并掌握基本的同步机制。

技能目标:1. 学生能够运用流程图或伪代码设计简单的进程管理策略。

2. 学生通过模拟实验,能够分析和评价不同进程调度算法的效果。

3. 学生能够通过小组合作,编写简单的进程同步程序,解决实际问题。

情感态度价值观目标:1. 学生通过本课程的学习,培养对计算机操作系统工作原理的兴趣,激发对信息技术领域的探索热情。

2. 学生在小组合作中,学会倾听、尊重他人意见,培养团队合作精神和解决问题的能力。

3. 学生能够认识到计算机科学技术对社会发展的重要性,增强对科技进步的敏感性和责任感。

课程性质分析:本课程为计算机科学领域的选修课程,旨在帮助学生深入理解计算机操作系统的核心概念,提高解决实际问题的能力。

学生特点分析:考虑到学生为高年级学生,具备一定的计算机操作基础和编程能力,对操作系统有一定了解,但需深化对进程管理的认识。

教学要求:结合学生特点和课程性质,课程目标设定既要注重理论知识的学习,也要关注实践技能的培养,同时关注学生情感态度价值观的塑造。

通过具体可衡量的学习成果,确保学生能够达到课程预期目标。

二、教学内容1. 进程管理基本概念:包括进程的定义、特征、状态及其转换,进程控制块的作用与内容。

2. 进程调度算法:研究进程调度的基本方法,如先来先服务(FCFS)、短作业优先(SJF)、优先级调度、时间片轮转等算法,分析各自优缺点。

3. 进程同步与互斥:介绍进程同步、互斥的概念,探讨同步机制如信号量、管程等,并分析经典同步问题,如生产者-消费者问题、读者-写者问题。

4. 进程通信:讲解进程间通信的方式,如消息传递、共享内存等,以及相关的通信协议。

5. 模拟实验:设计实验环节,让学生通过模拟软件或编程实践,加深对进程管理原理的理解。

进程管理模拟

进程管理模拟
查看置换后内存进程情况
4.杀死进程
进程杀死后运行结果(用负数来表示进程已经被杀死)
5进程之间的通讯(通过进程值的单偶关系来改变进程中标志量的值简单的描述进程之间的通讯)
实验总结
通过这次实验,使我对操作系统中的进程的概念有了进一步的了解。通过自己实际编写程序,对进程的创建以、查看、换出以及杀死某个进程等操作更加熟悉,是对课本知识的一次检验和加深印象的过程。
}பைடு நூலகம்
else
{
printf("\n请输入新进程的pid\n");
scanf("%d",&neicun[shumu].pid);
printf("\n请输入新进程的优先级\n");
scanf("%d",&neicun[shumu].youxian);
printf("\n请输入新进程的大小\n");
scanf("%d",&neicun[shumu].daxiao);
{
neicun[j].flag=22;
printf("\n发现偶数进程时,进程%d标志变量为%d",j,neicun[j].flag);//当进程中进程值为偶数,把所有进程中的标志位置
}
}
for(n=0;n<shumu;n++)
if(neicun[n].pid%2==1)
{
for(m=1;m<shumu;m++)
neicun[j].pid=-1;
printf("此进程%d被杀死",p);
}
}
}
voidtongxun()//通过进程是单双数改变进程中的参数,来达到进程之间通讯的简单描述

C语言模拟进程管理

C语言模拟进程管理

操作系统课程设计报告目录一需求分析 (2)二概要设计 (2)三详细设计(含主要代码) (3)四调试分析、测试结果 (8)五用户使用说明....................................................... 错误!未定义书签。

六后记....................................................................... 错误!未定义书签。

七参考资料............................................................... 错误!未定义书签。

一需求分析在多道处理程序运行环境下,进程数目一般多于处理机数目,使得进程要通过竞争来使用处理机。

这就要求系统能按照某种算法,动态地把处理机分配给就绪队列中的一个进程,使之运行,分配处理机的任务是由金城调度程序完成的。

一个进程被创建后,系统为了便于对进程进行管理,将系统中的所有进程按照其状态,将其组成不同的进程队列。

于是系统中有运行进程队列、就绪队列和各种事件的进程等待队列。

进程调度的功能就是从就绪队列中挑选一个进程到处理机上运行。

进程调度的算法有多种,常用的有优先级调度算法、先来先服务算法、时间片轮转算法。

二概要设计<一>最高优先级优先调度算法动态优先数是指在进程创建时先确定一个初始优先数,以后在进程运行中随着进程特性的改变不断修改优先数,这样,由于开始优先数很低而得不到CPU的进程,就能因为等待时间的增长而优先数变为最高而得到CPU运行。

例如:在进程获得一次CPU后就将其优先数减少3。

或者,进程等待的时间超过某一时限时增加其优先数的值,等等。

<二>简单轮转法调度算法所有就绪进程按 FCFS排成一个队列,总是把处理机分配给队首的进程,各进程占用CPU的时间片相同。

即将CPU的处理时间划分成一个个相同的时间片,就绪队列的诸进程轮流运行一个时间片。

模拟进程管理系统的说明文档

模拟进程管理系统的说明文档

模拟进程管理系统的说明文档老师,我在例子的基础上将进程之间通信改了一下,加了直接通信和间接通信!但是间接通信有点儿难,我没做出来!!!下面是进程之间通信的运行结果。

代码和注释如下:#include <conio.h>#include <stdio.h>#include <stdlib.h>#include <string.h>struct ProcessType //进程控制块{char Pid[10]; //进程标识符char Priority[10]; //优先级char Size[10]; //大小char Message[10]; //信息};struct ProcessType Ready[20];//就绪数组。

struct ProcessType Hung[20]; //挂起数组;struct ProcessType Cpu; //运行进程。

int Number1=0,Number2=0,First=0; //Number1是就绪队列中的进程的个数,Number2是挂起队//列中的进程个数,First是判断是否是第一次输入进程。

void Create() //新建进程。

{if(Number1>20) //最大进程数为{printf("\n就绪进程已满,请先删除或挂起进程\n");}else{if(First==0){printf("\n这是你第一次输入进程信息,它将直接调入CPU运行!"); printf("\n请输入新进程的Pid\n");scanf("%s",&Cpu.Pid);printf("请输入新进程的优先级\n");scanf("%s",&Cpu.Priority);printf("请输入新进程的大小\n");scanf("%s",&Cpu.Size);First++;}else{printf("\n请输入新进程的Pid\n");scanf("%s",&Ready[Number1].Pid);printf("请输入新进程的优先级\n");scanf("%s",&Ready[Number1].Priority);printf("请输入新进程的大小\n");scanf("%s",&Ready[Number1].Size);Number1++;}}}void Run()//查看运行进程。

进程模拟课程设计

进程模拟课程设计

进程模拟课程设计一、课程目标知识目标:1. 学生能理解进程模拟的基本概念,掌握进程的基本状态和转换条件。

2. 学生能够运用流程图、伪代码等方式描述进程的运行过程。

3. 学生了解操作系统中进程管理的基本原理,并能够解释进程调度、同步和互斥等相关知识。

技能目标:1. 学生能够运用所学知识,设计简单的进程模拟程序,实现进程的创建、运行和终止。

2. 学生通过实际操作,学会使用至少一种编程工具进行进程模拟,提高编程实践能力。

3. 学生能够分析并解决进程管理中可能出现的问题,如死锁、饥饿等。

情感态度价值观目标:1. 培养学生对计算机科学和操作系统的兴趣,激发他们探索未知、积极进取的精神。

2. 增强学生的团队合作意识,使他们学会在团队中沟通、协作,共同完成任务。

3. 培养学生严谨、务实的科学态度,让他们认识到进程管理在计算机系统中的重要性。

本课程针对年级学生的认知特点和学科要求,以实际操作为导向,注重理论与实践相结合。

通过本课程的学习,学生将掌握进程模拟的基本知识和技能,培养他们解决实际问题的能力,同时提升对计算机科学的兴趣和情感态度。

为实现课程目标,后续教学设计和评估将围绕具体学习成果展开,确保教学效果的达成。

二、教学内容本课程教学内容以《计算机操作系统》教材中进程管理章节为基础,涵盖以下要点:1. 进程基本概念:进程的定义、进程与程序的区别、进程的属性。

2. 进程状态及转换:运行、就绪、阻塞状态,状态转换条件。

3. 进程控制块(PCB):作用、内容、管理方式。

4. 进程调度:进程调度算法,如FCFS、SJF、优先级调度等。

5. 进程同步与互斥:同步机制、互斥概念、生产者-消费者问题、哲学家就餐问题。

6. 死锁与饥饿:死锁的定义、预防、避免、检测与解除;饥饿现象及其解决方案。

7. 进程通信:进程间通信方式,如管道、消息队列、共享内存等。

教学大纲安排如下:第一课时:进程基本概念、进程状态及转换。

第二课时:进程控制块、进程调度。

进程管理模拟课程设计

进程管理模拟课程设计

进程管理模拟课程设计一、课程目标知识目标:1. 理解进程管理的基本概念,掌握进程的定义、进程的状态以及进程控制块的作用;2. 掌握进程的创建、终止、同步和互斥等基本操作,了解进程调度算法及其特点;3. 了解操作系统中进程管理模块的设计原理,理解进程管理对系统性能的影响。

技能目标:1. 能够运用进程管理的基本理论,分析实际操作系统中的进程管理问题;2. 学会使用流程图、伪代码等方法描述进程的创建、同步和互斥过程;3. 能够设计简单的进程调度算法,并对不同算法进行性能分析。

情感态度价值观目标:1. 培养学生对操作系统学科的兴趣,激发他们探究进程管理技术的热情;2. 培养学生的团队合作精神,使他们能够在学习过程中互相帮助、共同进步;3. 增强学生的信息安全意识,使他们认识到进程管理在操作系统安全中的重要性。

本课程针对高年级学生,课程性质为理论性与实践性相结合。

在分析课程性质、学生特点和教学要求的基础上,将课程目标分解为具体的学习成果,以便于后续的教学设计和评估。

通过本课程的学习,学生能够掌握进程管理的基本理论,具备一定的进程管理实践能力,并培养积极的情感态度价值观。

二、教学内容1. 进程管理概述- 进程与线程的概念及其区别- 进程的创建、终止和状态转换- 进程控制块的作用和结构2. 进程同步与互斥- 进程同步的基本概念- 互斥锁、信号量、管程等同步机制- 生产者-消费者问题、哲学家就餐问题等经典同步问题3. 进程调度- 进程调度算法:FCFS、SJF、RR、优先级调度等- 调度算法的性能比较和分析- 多级反馈队列调度算法原理4. 死锁与饥饿- 死锁的定义、产生原因及预防、避免、检测和解除方法- 饥饿的原因和解决方案5. 操作系统进程管理案例分析- 分析具体操作系统(如Linux)的进程管理模块- 进程管理在实际操作系统中的应用教学内容按照教学大纲安排,与课本章节相对应,确保科学性和系统性。

在教学过程中,教师将根据学生的实际情况,适时调整教学内容和进度,保证学生能够扎实掌握进程管理的基本理论和实践技能。

c语言实现多级反馈队列调度的算法模拟进程的控制

c语言实现多级反馈队列调度的算法模拟进程的控制

c语言实现多级反馈队列调度的算法模拟进程的控制目录1. 引言1.1 背景和意义1.2 结构概述1.3 目的2. 多级反馈队列调度算法2.1 基本原理2.2 算法设计思路2.3 算法流程图3. C语言实现模拟进程控制3.1 数据结构定义3.2 进程创建与销毁3.3 进程调度与执行4. 实验结果与分析4.1 实验环境介绍4.2 实验结果展示4.3 结果分析与讨论5. 结论与展望5.1 结论总结5.2 存在问题与改进方向1. 引言1.1 背景和意义在计算机科学领域,进程调度是操作系统中非常重要的一个功能。

它负责决定哪个进程可以使用CPU并以何种顺序执行。

进程调度算法的优劣直接影响了系统的性能和效率。

多级反馈队列调度算法是一种常用的进程调度算法之一,它可以根据进程的类型和优先级将进程划分到不同的队列中,并根据优先级来决定进程的执行顺序。

该算法兼具公平性和高响应时间两个特点,适合应用于多任务环境下。

本文旨在使用C语言实现模拟多级反馈队列调度算法,并通过模拟进程控制过程,探讨其在实际应用中的表现。

通过实验结果与分析,我们将评估该算法在不同场景下的性能指标,并对其中存在问题提出改进方向。

1.2 结构概述本文共分为五个部分组成:•引言:介绍本文撰写目的、研究背景以及多级反馈队列调度算法在进程控制中的重要性。

•多级反馈队列调度算法:详细介绍多级反馈队列调度算法的基本原理、设计思路和算法流程图。

•C语言实现模拟进程控制:描述C语言中如何定义数据结构以及实现进程的创建、销毁以及调度和执行过程。

•实验结果与分析:介绍实验环境并展示实验结果,对结果进行分析和讨论。

•结论与展望:总结本文的研究成果,并提出该算法在应用过程中存在的问题以及改进方向。

通过以上结构安排,我们将全面深入地探讨多级反馈队列调度算法在模拟进程控制中的应用。

1.3 目的本文旨在通过使用C语言实现多级反馈队列调度算法,模拟进程控制过程。

通过对该算法进行分析和实验,目标如下:1.探讨多级反馈队列调度算法在不同场景下的优劣势,并对其性能指标进行评估。

模拟操作系统进程调度和管理

模拟操作系统进程调度和管理
{
Q=(struct pro *)malloc(sizeof(pro));
Q->next=NULL;
}
InsertQueue(struct pro *&Q,struct pro *p) //按优先数由大到小插入结点
{
struct pro *t=Q;
while(t->next!=NULL&&(t->next)->priority>p->priority)
printf("模拟进程调度");
for(i=0;i<34;i++)
printf("%c",003);
CreatQueue(Q);
next:p=(struct pro *)malloc(sizeof(pro));
p->next=NULL;
printf("当前处于就绪态的进程有:\n");
PrintQueue(Q);
s->time=(rand())%10+1;
s->priority=(rand())%10;
s->state='R';
s->next=NULL;
InsertQueue(Q,s);
}
}
PrintQueue(struct pro *Q)
{
struct pro *s=Q->next;
while(s!=NULL)
p->priority=s->priority;
p->time=s->time;
free(s);
}
int EmptyQueue(struct pro *Q)

实验5 进程管理模拟

实验5 进程管理模拟

实验5 进程管理模拟一、实验目的进程是操作系统中最核心的概念,是了解操作系统实质的关键。

本实验的目在于:加深对进程概念的理解;熟悉操作系统在管理进程时所采用的数据结构;掌握基本的进程状态及其转换;熟悉主要的进程调度算法。

二、实验要求设计一个允许n个进程并发执行的进程管理模拟系统。

该系统具有以下功能:(1)建立良好的数据结构实现对进程的有效管理(2)进程控制功能(3)进程调度(4)显示进程执行期间状态的变化。

系统在模拟时,可将各进程对资源的使用情况直接以数据的形式输入或者随机生成。

三、实验环境Linux C四、范例(使用Visual C++ 6.0)为了体现计算机在运行时各设备可以并行工作,本例设置了三个线程CPU_Thread、IO1_Thread、IO2_Thread分别模拟三个设备。

在通过调度程序Scheduler(线程)调度,多个进程根据各自的资源使用情况可同时在这三个设备上穿插运行。

#include "stdafx.h"#define STRICT#define WIN32_LEAN_AND_MEAN#include "iostream.h"#include <windows.h>#include <winbase.h>#include <stdio.h>#include <stdlib.h>#include <time.h>extern "C"#define MAXPCBCOUNT 20#define MAXRESCOUNT 1000#define TIMESLICE 10//定义进程的基本状态typedef enum ProcStatus{ PS_READY=0, PS_RUN=1 , PS_BLOCK=-1 } PROC_STA TUS;typedef enum ResourceID //系统中资源的编号,系统只有1CPU,及I/O设备IO1,IO2{ RES_CPU=1, RES_IO1=2, RES_IO2=3 } RESOURCE_ID;typedef struct ResNode //资源结点{ RESOURCE_ID ResID; //资源IDunsigned int Time; //使用时间int Next;}RESNODE;//定义PCB的组成typedef struct PCBNode{//Part1:进程标识符及名称int PID;char Name[256];//Part2:处理机现场信息。

进程管理器的模拟实现

进程管理器的模拟实现

衡阳师范学院《操作系统》课程设计题目:进程管理器的模拟实现系别:计算机科学系专业:物联网工程班级:1206班学生姓名:郑晓娟学号:12450218指导老师:王玉奇完成日期:2014年12月28日目录一、需求分析 (3)二、概要设计 (3)三、详细设计 (4)1.进程PCB结构体的定义 (4)2.创建模块 (4)3.查看模块 (5)4.换出模块 (6)5.杀死模块 (8)四、程序调试 (10)五、总结分析 (14)一、需求分析有时候我们需要去了解我们电脑的运行情况,掌握和管理它的进程,并对其异常情况给予操作和控制。

进程管理器就像我们了解和控制自己电脑运作的一个窗口,通过这个窗口我们可以查看到所有进程的运行情况,并对运行的进程加以管理和控制。

在本课程设计中,进入模拟进程系统后,可以根据请求选择“创建进程”创建新的进程。

还可以选择“查看进程“来查看当前正在运行的进程,以及该进程的相关的信息,其中包括进程的pid,进程优先级,进程大小和进程的内容,我们可以通过这些来了解计算机中每个进程的使用状况。

选择“换出进程”,可以挂起某个正在运行的进程。

选择“撤销进程”,可以停止某个正在运行的程序,并且释放其占用的资源。

选择“退出进程”,可以退出进程模拟系统。

二、概要设计程序流程:三、详细设计(1)进程PCB结构体的定义struct jincheng_type{ //定义表示进程信息的结构体int pid; //进程IDint youxian; //优先级int daxiao; //大小int zhuangtai; //进程的状态,这里用0表示没有建立或被杀死,1表示执行,2表示换出int neirong; //内容};(2)创建模块void create() //函数--创建一个新进程{if(shumu>=20) printf("\n内存已满,请先换出或杀死进程\n") //判断内存空间是否已满else{for(int i=0;i<20;i++)if(neicun[i].zhuangtai==0) break; //选出空着的内存单元给新进程使用printf("\n请输入新进程pid\n"); //输入新进程ID存至选出的内存单元scanf("%d",&(neicun[i].pid));for(int j=0;j<i;j++)if(neicun[i].pid==neicun[j].pid) //当输入的新进程与原有进程ID相同时,显示"该进程已存在"{printf("\n该进程已存在\n");return;}printf("\n请输入新进程优先级\n"); //输入新进程的优先级、大小和内容scanf("%d",&(neicun[i].youxian));printf("\n请输入新进程大小\n");scanf("%d",&(neicun[i].daxiao));printf("\n请输入新进程内容\n");scanf("%d",&(neicun[i].neirong));neicun[i].zhuangtai=1; //将新进程的内存单元状态(zhuangtai)设成"1",以表示存在且未被换出shumu++; //正在运行的进程数目加一}}(3)查看模块void run() //函数--查看正在运行的进程{for(int i=0;i<20;i++){if(neicun[i].zhuangtai==1) //将存在且未被挂起(即zhuangtai=1)的进程显示出来,若存在这样的程序,则将flag设成1 {printf("\n pid=%d",neicun[i].pid);printf("youxian=%d",neicun[i].youxian);printf("daxiao=%d",neicun[i].daxiao);printf("zhuangtai=%d",neicun[i].zhuangtai);printf("neirong=%d",neicun[i].neirong);flag=1;}}if(!flag)printf("\n当前没有运行进程\n"); //若当前没有运行进程(即flag=0),则显示"当前没有运行进程"}(4)换出模块void huanchu() //函数--换出进程{if(!shumu) //判断是否无进程存在{printf("\n当前没有进程存在\n");return;}printf("\n 输入换出进程ID值"); //输入需要换出的进程ID scanf("%d",&pid);for(int i=0;i<20;i++){if(pid==neicun[i].pid){if(neicun[i].zhuangtai==1) //若该ID代表的进程正在运行,则将其挂起,即将zhuangyai置成2,并将guaqi 加一{neicun[i].zhuangtai=2;guaqi++;printf("\n已经成功换出进程\n");}else if(neicun[i].zhuangtai==2)printf("\n要唤出的进程已被挂起\n"); //若该ID代表的进程已被挂起,即zhuangtai==2,则显示'要唤出的进程已被挂起'flag=1;break;}}if(!flag)printf("\n要换出的进程不存在\n"); //若进程不存在,给出显示}(4)杀死模块void kill() //函数--杀死进程{if(!shumu) //判断是否无进程存在{printf("\n当前没有进程存在\n");return;}printf("\n 输入杀死进程的ID值"); //读入要杀死的进程IDscanf("%d",&pid);for(int i=0;i<20;i++){if(pid==neicun[i].pid){if(neicun[i].zhuangtai==1) //若进程正在运行则再次询问是否要杀死,通过用户的反馈执行不同操作{printf("\n该进程正在运行,您确定要杀死吗?\n");printf("\n请输1:确定;0:不确定\n");scanf("%d",&flag);if(flag){neicun[i].zhuangtai=0; //将zhuangtai置为0,表示进程被杀死,并将shumu自减一shumu--;printf("\n已经成功杀死进程\n");}elseprintf("\要杀死的进程正在运行\n");}else if(neicun[i].zhuangtai==2) //若该进程已经被挂起,则直接杀死{neicun[i].zhuangtai=0;shumu--;printf("\n已经成功杀死进程\n");}flag=1;break;}}if(flag==0)printf("\n要杀死的进程不存在\n"); //若进程不存在,给出显示}四.调试运行本程序可以在VC++6.0的环境下。

  1. 1、下载文档前请自行甄别文档内容的完整性,平台不提供额外的编辑、内容补充、找答案等附加服务。
  2. 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
  3. 3、如文档侵犯您的权益,请联系客服反馈,我们会尽快为您处理(人工客服工作时间:9:00-18:30)。
<三>短作业优先调度算法
所有就绪进程按所需时间由少到多排成一个队列,依次运行队列中的进程,并列表显示出来,每个进程的开始运行时间减去进入内存时间就是该进程的等待时间,每个进程的结束运行时间减去进入内存时间就是该进程的周转时间,每个进程的周转时间除于服务时间就是带权周转时间。

一.优先权调度算法:
1、用户可以自行输入进程的数量,每一个进程由进程控制块( PCB)表示,各种队列均采用链表数据结构。
}
printf("**************************************************************************\n");
printf("输出结束\n");
getchar();
}
二.时间片轮转算法:
1、用户可以自行输入进程的数量,每一个进程由进程控制块( PCB)表示,各种队列均采用链表数据结构。
三、设计要求
(1)选择课程设计题目中的一个课题,独立完成。
(2)良好的沟通和合作能力
(3)充分运用前序课所学的软件工程、程序设计等相关知识
(4)充分运用调试和排错技术
(5)简单测试驱动模块和桩模块的编写
(6)查阅相关资料,自学具体课题中涉及到的新知识。
(7)课题完成后必须按要求提交课程设计报告,格式规范,内容详实。
printf("**************************************************************************\n");
printf("输出结束\n");
getchar();
}

一.进入系统显示欢迎界面
二.如果选择P进行优先数算法则提示输入进程数:

<一>最高优先级优先调度算法
动态优先数是指在进程创建时先确定一个初始优先数, 以后在进程运行中随着进程特性的改变不断修改优先数,这样,由于开始优先数很低而得不到CPU的进程,就能因为等待时间的增长而优先数变为最高而得到CPU运行。
例如:在进程获得一次CPU后就将其优先数减少3。或者,进程等待的时间超过某一时限时增加其优先数的值,等等。
run->round+=timeSlice;
run->count++;
if(run->needtime <= 0){
run->needtime = 0;
run->next = finish;
finish = run;
if(run != tail){
tail->next = ready;
}
else{
ready = NULL;
ready = ready -> next;//就绪队列头指针移到下一个进程
}}
prt('r');}}
三.短作业优先调度算法
1,用户可以自行输入进程的数量,每一个进程由进程控制块( PCB)表示,各种队列均采用链表数据结构。
2,按照进程服务时间由少到多顺序排成一个队列。再按顺序依次执行。
主要代码:
void short_timefirst(char algo){
PC q;int t;prt3();
for(int j = 0; j< N ; j++){
p[j].state = 'R';
for(int i=0;i<N;i++)
{
if(p1[i].state == 'W') p1[i].waittime=Tim;
if(strcmp(p[j].name,p1[i].name)==0) {
p[j].needtime=0;
p[j].waittime=Tim;
Tim+=p[j].cputime;
printf("**************************************************************************\n");
}
for(int i=0;i<N;i++) prit(i);
10
指导教师签章:
教研室主任签章:
操作系统课程设计指导教师评语与成绩
指导教师评语:
课程设计表现成绩:
课程设计验收成绩:
课程设计报告成绩:
课程设计总成绩:
指导教师签章
2009年月日

在多道处理程序运行环境下,进程数目一般多于处理机数目,使得进程要通过竞争来使用处理机。这就要求系统能按照某种算法,动态地把处理机分配给就绪队列中的一个进程,使之运行,分配处理机的任务是由金城调度程序完成的。一个进程被创建后,系统为了便于对进程进行管理,将系统中的所有进程按照其状态,将其组成不同的进程队列。于是系统中有运行进程队列、就绪队列和各种事件的进程等待队列。进程调度的功能就是从就绪队列中挑选一个进程到处理机上运行。进程调度的算法有多种,常用的有优先级调度算法、先来先服务算法、时间片轮转算法。
q.prio-=3;
pp.push(q);
while(!pq.empty())
{
q = pq.top();
pq.pop();
if(q.needtime == 0)
q.state = 3;
prt2(algo , q);prt1(algo);
pp.push(q);
}
pq = pp;
pp = pqempty;
流程图
图. 简单轮转法调度算法流程图
主要代码:
void Roundrun(int timeSlice){
while(run != NULL){
run->cputime = run->cputime + timeSlice;
run->needtime = run->needtime - timeSlice;
5.结果分析。程序运行结果包括正确的输入及其输出结果和含有错误的输入及其输出结果。
6.编写课程设计报告;
设计报告要求:A4纸,详细设计部分主要叙述本人的工作内容
设计报告的格式:
(1)封面(题目、指导教师、专业、班级、姓名、学号)
(2)设计任务书
(3)目录
(4)需求分析
(5)概要设计
(6)详细设计(含主要代码)
2、进程控制块包含如下信息:进程号、cpu时间、所需要时间、优先数、状态等等。
3、在每次运行程序时都要输入“进程数量”、“进程名称及占用时间”。
4、按照优先数的高低进行排列
5、处理机调度队首元素运行。采用动态优先数办法,进程每运行一次优先数减“3”,同时将已运行时间加“1”。
6、进程运行一次后,若要求运行时间不等于已运行时间,则再将它加入就绪队列;否则将其状态置为“F”,且退出就绪队列。
[3]陈钟,刘强,C#编程语言程序设计与开发,北京,清华大学出版社,2006年8月。
[4]李春葆,苏光奎,数据结构算法与教程,北京,清华大学出版社,2005年6月。

#include<stdio.h>
#include<stdlib.h>
#include<string.h>
#include<queue>
三.输入进程号和运行时间:
四.输出优先数算法信息:
五.可以继续选择R进行时间片轮转算法,并输入时间片大小:
六.输出时间片轮转算法信息:
七.如果输入错误则结束程序:

本系统为模拟进程管理系统,界面美观,操作也比较简单,要按照提示信息一步步输入信息即可完成操作看到最终结果。

这个学期我们迎来了操作系统的课程设计,经过将近两个星期的程序设计,当遇到困难的时候我们谁都没有泄气而是努力的去查资料找方法,并且我们受到了指导老师的支持和鼓励,我在困难的时候想到了老师平时在给我们讲授知识的时候的样子,让我重新振作起来继续下面的工作,老师不厌其烦的给我们讲授知识,在此衷心的对老师说一声您辛苦了,与此同时我们还受到了许多同学的帮助。还要感谢学校给我们学校的实验室来进行试验,使我能够顺利完成这次的任务。我承诺我无论是在以后的学习还是工作中我都会认真努力的。
2、按照进程输入的先后顺序排成一个队列。再设一个队首指针指向第一个到达进程的首址。
3、执行处理机调度时,开始选择队首的第一个进程运行。另外,再设一个当前运行进程的指针,指向当前正在运行的进程。
4、考虑到代码的可重用性,轮转法调度程序和最高优先级优先调度是调用同一个模快进行输出
5、 在规定的时间片内进程是根据先来先服务的方式配列的,每个进程只运行时间片大小的时间然后转到下一个进程运行。直到所有进程运行完为止。
四、设计内容
1.根据设计题目的要求,充分地分析和理解问题,明确问题要求做什么。
2.根据实现的功能,划分出合理的模块,明确模块间的关系。
3.编程实现所设计的模块。
4.程序调试与测试。采用自底向上,分模块进行,即先调试低层函数。能够熟练掌握调试工具的各种功能,设计测试数据确定疑点,通过修改程序来证实它或绕过它。调试正确后,认真整理源程序及其注释,形成格式和风格良好的源程序清单和结果;
if(q.state != 3)
q.state = 1;
prt2(algo , q);
if(q.state !=3 )
q.state = 2;
q.cputime++;
if(q.needtime>0)
q.needtime--;
if(q.needtime == 0)
q.state = 3;
if(q.state!=3)
相关文档
最新文档