当前位置：文档之家 › 实验5 进程管理模拟

实验5 进程管理模拟

  • 格式：doc
  • 大小：74.00 KB
  • 文档页数：10

实验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：处理机现场信息。

unsigned long Reg1; //通用寄存器1，unsigned long Reg2; //通用寄存器2，Reg3—Reg8略去unsigned long PC; //指令计数器PCunsigned long PSW; //程序状态字//Part3：进程的调度信息PROC_STATUS Status; //进程状态int Priority; //进程优先级//Part4：进程的控制信息int PreProc; //链接指针，前驱int NextProc; //链接指针，后继int CodeAddr ;int DataAddr ;}PCB;PCB PCBTable[MAXPCBCOUNT]; //定义了PCB表RESNODE RESTable[MAXRESCOUNT]; //定义了资源表int ProcCount ; //当前系统中进程总数int ResHead_Free; //资源表空间链表的头指针int Head_Free; //空闲空间链表的头指针int Head_Ready; //就绪队列头指针int Head_Run; //运行队列头指针int Head_Block1; //IO1的阻塞队列头指针int Head_Block2; //IO2的阻塞队列头指针HANDLE hSystem[4]; //系统线程Handle，0-3分别是调度进程Scheduler，CPU,IO1,IO2 unsigned long PC ; //存储进程的执行位置unsigned long Reg1; //用来资源类型unsigned long Reg2; //用来使用时间int NewPCB(void) //申请PCB空间{ int nPos;if (Head_Free!=-1 ){ nPos=Head_Free;Head_Free=PCBTable[Head_Free].NextProc;}elsenPos= -1;return nPos;}void FreePCB(int nPos) //释放给定的PCB空间{if(nPos>=0 && nPos<MAXPCBCOUNT){ PCBTable[nPos].NextProc=Head_Free;Head_Free=nPos;}}int NewRES(void) //申请资源空间{ int nPos;if (ResHead_Free!=-1 ){ nPos=ResHead_Free;ResHead_Free=RESTable[ResHead_Free].Next;}elsenPos= -1;return nPos;}void FreeRES(int nPos) //释放给定的资源空间{if(nPos>=0 && nPos<MAXRESCOUNT){ RESTable[nPos].Next=ResHead_Free;ResHead_Free=nPos;}}void AddtoQueue(int *Head, int nPos) //将给定的进程加入到给定队列的末尾{ int nPosPre;if( *Head==-1 ){ PCBTable[nPos].NextProc=-1;PCBTable[nPos].PreProc=-1;*Head=nPos;}else{ nPosPre=*Head;while( PCBTable[nPosPre].NextProc!=-1 )nPosPre=PCBTable[nPosPre].NextProc;PCBTable[nPosPre].NextProc=nPos;PCBTable[nPos].PreProc=nPosPre;PCBTable[nPos].NextProc=-1;}}void Block(int pcbID , RESOURCE_ID ResID ){ //保存该进程的CPU现场PCBTable[pcbID].Reg1=Reg1;PCBTable[pcbID].Reg2=Reg2;PCBTable[pcbID].PC=PC;PCBTable[pcbID].Status=PS_BLOCK;if(ResID==RES_IO1) //根据其阻塞的原因，将其插入到相应的阻塞队列中{ AddtoQueue(&Head_Block1, pcbID);cout<<"进程："<<PCBTable[pcbID].PID<<" "<<PCBTable[pcbID].Name<<"进入阻塞队列1!"<<endl;ResumeThread(hSystem[2]);}else{ AddtoQueue(&Head_Block2, pcbID);cout<<"进程："<<PCBTable[pcbID].PID<<" "<<PCBTable[pcbID].Name<<"进入阻塞队列2!"<<endl;ResumeThread(hSystem[3]);}Head_Run=-1;}void Wakeup(int pcbID, RESOURCE_ID ResID){ //将其插入就绪队列的末尾if(ResID==RES_IO1)Head_Block1=PCBTable[pcbID].NextProc;elseHead_Block2=PCBTable[pcbID].NextProc;AddtoQueue(&Head_Ready, pcbID);cout<<"进程："<<PCBTable[pcbID].PID<<" "<<PCBTable[pcbID].Name<<"从进入就绪队列!"<<endl;}void DestroyProcess(int pcbID){ cout<<"进程："<<PCBTable[pcbID].PID<<" "<<PCBTable[pcbID].Name<<"执行完毕!"<<endl;FreePCB(pcbID);ProcCount--; //进程总数减少Head_Run=-1;}void TimeOut(int pcbID){ //保存该进程的CPU现场PCBTable[pcbID].Reg1=Reg1;PCBTable[pcbID].Reg2=Reg2;PCBTable[pcbID].PC=PC;PCBTable[pcbID].Status=PS_READY;//插入到就绪队列中cout<<"进程："<<PCBTable[pcbID].PID<<" "<<PCBTable[pcbID].Name<<"时间片用完，进入就绪队列1!"<<endl;AddtoQueue(&Head_Ready, pcbID);Head_Run=-1;}DWORD WINAPI Scheduler( LPVOID lpPara) //进程调度程序{ int nSel;while(1){ if(Head_Run==-1) //CPU空闲，选择一个合适的进程投入运行{ //此处选用FIFS算法if(Head_Ready!=-1){ nSel=Head_Ready;PCBTable[nSel].Status=PS_RUN;Head_Ready=PCBTable[Head_Ready].NextProc;Head_Run=nSel;cout<<"进程："<<PCBTable[nSel].PID<<" "<<PCBTable[nSel].Name<<"被进程调度选中投入运行!"<<endl;ResumeThread(hSystem[1]); //唤醒CPU，继续工作}}if(ProcCount==0) //系统中所有用户进程运行完毕，退出{TerminateThread(hSystem[1],0); //停止CPUTerminateThread(hSystem[2],0); //停止IO1TerminateThread(hSystem[3],0); //停止IO2break;}}return 0;}DWORD WINAPI CPU_Thread(LPVOID lpPara ) //用来模拟CPU{ PCB *pcbRun;int nTime;while(1){ nTime=TIMESLICE;if (Head_Run!=-1){ PCB * pcbRun=&PCBTable[Head_Run];cout<<"进程："<<pcbRun->PID<<" "<<pcbRun->Name<<"开始运行!"<<endl;Reg1=pcbRun->Reg1;Reg2=pcbRun->Reg2;PC=pcbRun->PC;if (Reg1!=RES_CPU && Reg1!=0){ cout<<"进程调度出现错误!"<<endl;ExitThread(0);}while( Reg1==RES_CPU ||Reg1==0 ) //开始运行{ if(Reg2<=0){ if(PC==-1){ DestroyProcess (pcbRun->PID); //进程执行完毕，将进程撤销break;}else{ Reg1=RESTable[PC].ResID;Reg2=RESTable[PC].Time;PC=RESTable[PC].Next;}}nTime--; //时间减少Reg2 --; //剩余时间减少if(nTime==0) //时间片用完{ TimeOut(pcbRun->PID );break;}}if(Reg1==RES_IO1||Reg1==RES_IO2)Block(pcbRun->PID,(RESOURCE_ID)Reg1);}SuspendThread(GetCurrentThread()); //无进程可运行，CPU休息}return 0;}DWORD WINAPI IO1_Thread(LPVOID AA ) //用来模拟IO1{ PCB *pcbBlock;int nTime;while(1){ while(Head_Block1!=-1){ pcbBlock=&PCBTable[Head_Block1];if(pcbBlock->Reg1!=RES_IO1){ cout<<"阻塞原语出现错误!"<<endl;ExitThread(0);}cout<<"进程："<<pcbBlock->PID<<" "<<pcbBlock->Name<<"开始使用IO1!"<<endl;nTime=pcbBlock->Reg2;while(nTime--)Sleep(2); //进行IO操作cout<<"进程："<<pcbBlock->PID<<" "<<pcbBlock->Name<<"使用IO1结束"<<endl;pcbBlock->Reg1=0;pcbBlock->Reg2=0;Wakeup(pcbBlock->PID, RES_IO1); //唤醒阻塞}SuspendThread(GetCurrentThread()); //无进程使用IO1设备，休息}return 0;}DWORD WINAPI IO2_Thread(LPVOID lpPara) //用来模拟IO2{PCB *pcbBlock;int nTime;while(1){ while(Head_Block2!=-1){ pcbBlock=&PCBTable[Head_Block2];if(pcbBlock->Reg1!=RES_IO2){ cout<<"阻塞原语出现错误!"<<endl;ExitThread(0);}cout<<"进程："<<pcbBlock->PID<<" "<<pcbBlock->Name<<"开始使用IO2"<<endl;nTime=pcbBlock->Reg2;while(nTime--)Sleep(2); //进行IO操作cout<<"进程："<<pcbBlock->PID<<" "<<pcbBlock->Name<<"使用IO2结束"<<endl;pcbBlock->Reg1=0;pcbBlock->Reg2=0;Wakeup(pcbBlock->PID, RES_IO2); //唤醒阻塞}SuspendThread(GetCurrentThread()); //无进程使用IO2设备，休息}return 0;}void Init(void){ int i;for(i=0;i<MAXPCBCOUNT;i++) //初始化PCB表，将表中的空闲空间构成静态链表PCBTable[i].NextProc=i+1;PCBTable[MAXPCBCOUNT-1].NextProc=-1;Head_Free=0;//指向空闲空间链表的第一个结点for(i=0;i<MAXRESCOUNT;i++)//初始化RES表，将表的空闲空间构成静态链表RESTable[i].Next=i+1;RESTable[MAXRESCOUNT-1].Next=-1;ResHead_Free=0;//指向空闲空间链表的第一个结点//就绪、运行、阻塞队列为空Head_Ready=-1;Head_Run=-1;Head_Block1=-1;Head_Block2=-1;ProcCount=0; //进程总数为0}//创建进程bool CreateProcess(){ int nPos, nResPos, nResPosPre;int nResID, nTime;nPos=NewPCB();if(nPos<0 ) //如果申请失败，则返回return false;PCBTable[nPos].PID=nPos; //设定进程ID为其在PCB表中的位置PCBTable[nPos].Status=PS_READY;cout<<"\n请输入进程名：";cin>>PCBTable[nPos].Name;cout<<"\n请输入进程的优先级：";cin>>PCBTable[nPos].Priority;nResPosPre=PCBTable[nPos].CodeAddr=-1;while(1){ cout<<"\n请输入该进程对资源的使用情况，当前系统中的资源及其编号如下：";cout<<"\n 1 ------------ CPU";cout<<"\n 2 ------------ IO1";cout<<"\n 3 ------------ IO2";cout<<"\n请输入资源号及使用时间，输入0退出，格式[资源号时间]:";cin>>nResID>>nTime;if ( nResID>=1 && nResID<=3 && nTime>0){ nResPos=NewRES();if(nResPos<0) //申请资源空间失败{ cout<<"\n申请资源空间失败！";break;}RESTable[nResPos].ResID=(RESOURCE_ID) nResID;RESTable[nResPos].Time=nTime;RESTable[nResPos].Next=-1;if(nResPosPre==-1)PCBTable[nPos].CodeAddr=nResPos;elseRESTable[nResPosPre].Next=nResPos;nResPosPre=nResPos;}else if(nResID==0)break;elsecout<<"\n输入的数据非法！！！";}PCBTable[nPos].Reg1=0;PCBTable[nPos].Reg2=0;PCBTable[nPos].PC=PCBTable[nPos].CodeAddr;AddtoQueue(&Head_Ready, nPos); //将该进程插入到就绪队列末尾中ProcCount++;return true;}void Start(void){ DWORD id;hSystem[0]=CreateThread(NULL, 0 , Scheduler,NULL ,THREAD_PRIORITY_ABOVE_NORMAL, &id);hSystem[1]=CreateThread(NULL, 0, CPU_Thread, &PCBTable[Head_Ready],THREAD_PRIORITY_NORMAL, &id);hSystem[2]=CreateThread(NULL, 0, IO1_Thread, &PCBTable[Head_Ready],THREAD_PRIORITY_NORMAL, &id);hSystem[3]=CreateThread(NULL, 0, IO2_Thread, &PCBTable[Head_Ready],THREAD_PRIORITY_NORMAL, &id);WaitForMultipleObjects(4, hSystem, TRUE, INFINITE);}void main(void){int nSel,i ;Init();while(1){ cout<<"\n************进程管理模拟程序主菜单*****************：";cout<<"\n 1 ------------ 创建进程";cout<<"\n 2 ------------ 进程浏览";cout<<"\n 3 ------------ 运行";cout<<"\n 0 ------------ 退出系统";cout<<"\n请输入你的选择[0－3]:";cin>>nSel;switch(nSel){case 1: CreateProcess(); break;case 2: break;case 3: Start(); break;case 0:for (i = 0; i < 4; i++)CloseHandle(hSystem[i]);exit(0);break;default:cout<<"\n输入了错误的选择！！！"<<endl; break;}}}五、实验任务1、熟悉进程管理与组织时所采用的数据结构，掌握进程控制时各原语的功能、掌握常见的进程调度算法。

合集下载

进程管理实验报告

进程管理实验报告

实验名称: 进程管理实验要求:阅读后面的C语言实例，修改程序，使其优先数在运行期间可以变化(动态优先数)。

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

关键问题:读懂源程序代码，了解进程管理的方式，并设计一个算法使程序能在运行过程中修改进程优先级。

设计思路:在进程控制块中定义一个记录进程中断次数的变量，在block函数中设置跟踪并记录进程中断次数，在调度函数schedule中设置算法，在进程中断3次后将该进程的优先级提升至最高。

改动后的代码:#include <stdio.h>#define TRUE 1#define FALSE 0#define MAXPRI 100#define NIL -1//进程控制块struct {int id; //进程号char status; //进程状态，'e'-执行态'r'-高就绪态't'-低就绪态'w'-等待态'c'-完成态int nextwr; //等待链指针，指示在同一信号量上等待的下一个等待进程的进程号。

int priority; //进程优先数，值越小，优先级越高。

int c;//进程中断次数}pcb[3];//共3个进程//s1、s2为三个进程共享的变量；seed为随机值；registeri模拟寄存器值,存放计算的重复次数。

int registeri,s1,s2,seed,exe=NIL;//exe为当前运行（占有cpu）的进程号//2个信号量sem[0]、sem[1],分别与共享变量s1、s2相联系。

//对应信号量sem[0]、sem[1]分别有两个阻塞队列，队列首由sem[].firstwr指定，队列链指针是pcb[].nextwrstruct{int value;//信号量值int firstwr;//等待该信号量的阻塞队列的首个进程号}sem[2];//三个进程的现场保留区，其中savearea[][0]为寄存器内容，savearea[][1]为下一条指令地址。

进程管理模拟实验

进程管理模拟实验

进程管理一、目的与要求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. 掌握Linux系统中进程的创建、调度、同步和通信方法。

3. 熟悉进程的阻塞、挂起、恢复和终止操作。

4. 学习使用相关命令和工具进行进程管理和调试。

二、实验环境操作系统：Linux开发环境：GCC、Xshell三、实验内容1. 进程创建与调度2. 进程同步与通信3. 进程阻塞与恢复4. 进程终止与调试四、实验步骤1. 进程创建与调度（1）编写一个简单的C程序，使用fork()函数创建一个子进程。

（2）在父进程中，使用getpid()和getppid()函数获取进程ID和父进程ID。

（3）使用ps命令查看当前系统中的进程，观察父进程和子进程的状态。

（4）使用waitpid()函数等待子进程结束。

2. 进程同步与通信（1）编写一个使用管道（pipe）进行进程间通信的C程序。

（2）父进程向管道中写入数据，子进程从管道中读取数据。

（3）使用ps命令查看进程状态，观察管道通信的效果。

（4）编写一个使用信号量（semaphore）进行进程同步的C程序。

（5）使用sem_wait()和sem_post()函数实现进程同步。

3. 进程阻塞与恢复（1）编写一个使用sleep()函数使进程阻塞的C程序。

（2）在父进程中，使用waitpid()函数等待阻塞的子进程结束。

（3）使用kill()函数向阻塞的进程发送SIGCONT信号，使其恢复执行。

4. 进程终止与调试（1）编写一个使用exit()函数终止进程的C程序。

（2）在父进程中，使用waitpid()函数等待终止的子进程。

（3）使用gdb调试器分析程序运行过程中出现的问题。

五、实验结果与分析1. 进程创建与调度实验结果表明，使用fork()函数成功创建了子进程，父进程和子进程的进程ID和父进程ID被正确获取。

通过ps命令，可以观察到父进程和子进程的状态。

2. 进程同步与通信实验结果表明，管道通信可以成功实现父进程和子进程之间的数据传递。

进程管理实验报告源代码(3篇)

进程管理实验报告源代码(3篇)

第1篇---进程管理实验报告一、实验目的1. 理解进程的概念和进程管理的基本原理。

2. 掌握进程的创建、调度、同步和通信等操作。

3. 通过编程实现简单的进程管理功能。

二、实验环境1. 操作系统：Windows/Linux2. 编程语言：C/C++3. 开发环境：Visual Studio/Code::Blocks三、实验内容1. 进程的创建与终止2. 进程的同步与互斥3. 进程的通信4. 进程调度算法四、实验步骤1. 进程的创建与终止```cinclude <stdio.h>include <sys/types.h>include <unistd.h>int main() {pid_t pid;// 创建子进程pid = fork();if (pid < 0) {// 创建进程失败perror("fork failed");return 1;} else if (pid == 0) {// 子进程printf("Child process, PID: %d\n", getpid()); // 执行子进程的任务...sleep(5); // 子进程暂停5秒_exit(0); // 子进程退出} else {// 父进程printf("Parent process, PID: %d\n", getpid()); wait(NULL); // 等待子进程结束printf("Child process has terminated.\n");}return 0;}```2. 进程的同步与互斥```cinclude <stdio.h>include <pthread.h>pthread_mutex_t mutex;void thread_func(void arg) {pthread_mutex_lock(&mutex); // 加锁printf("Thread %ld is running\n", (long)arg);sleep(1); // 模拟任务执行pthread_mutex_unlock(&mutex); // 解锁return NULL;}int main() {pthread_t thread1, thread2;// 初始化互斥锁pthread_mutex_init(&mutex, NULL);// 创建线程pthread_create(&thread1, NULL, thread_func, (void )1); pthread_create(&thread2, NULL, thread_func, (void )2); // 等待线程结束pthread_join(thread1, NULL);pthread_join(thread2, NULL);// 销毁互斥锁pthread_mutex_destroy(&mutex);return 0;}```3. 进程的通信```cinclude <stdio.h>include <stdlib.h>include <sys/ipc.h>include <sys/shm.h>int main() {key_t key;int shmid;int data;// 生成共享内存标识符key = ftok("shmfile", 65);// 创建共享内存段shmid = shmget(key, sizeof(int), 0666 | IPC_CREAT); if (shmid == -1) {perror("shmget failed");exit(1);}// 连接到共享内存段data = (int )shmat(shmid, (void )0, 0);if (data == (int )(-1)) {perror("shmat failed");exit(1);}// 使用共享内存data = 100;printf("Data in shared memory: %d\n", data); // 分离共享内存段if (shmdt(data) == -1) {perror("shmdt failed");exit(1);}// 删除共享内存段if (shmctl(shmid, IPC_RMID, NULL) == -1) { perror("shmctl failed");exit(1);}return 0;}```4. 进程调度算法```cinclude <stdio.h>include <stdlib.h>include <sys/time.h>typedef struct {int pid;int arrival_time;int burst_time;int waiting_time;int turnaround_time;} Process;int main() {Process processes[] = {{1, 0, 5, 0, 0},{2, 1, 3, 0, 0},{3, 4, 8, 0, 0}};int n = sizeof(processes) / sizeof(processes[0]);// 计算等待时间和周转时间int total_waiting_time = 0, total_turnaround_time = 0;for (int i = 0; i < n; i++) {if (i == 0) {processes[i].waiting_time = 0;} else {processes[i].waiting_time = processes[i - 1].turnaround_time;}processes[i].turnaround_time = processes[i].burst_time + processes[i].waiting_time;total_waiting_time += processes[i].waiting_time;total_turnaround_time += processes[i].turnaround_time;}printf("Average Waiting Time: %f\n", (float)total_waiting_time / n);printf("Average Turnaround Time: %f\n", (float)total_turnaround_time / n);return 0;}```五、实验结果与分析（此处应填写实验结果，包括运行程序输出、图表等，以及对实验结果的分析。