操作系统实验—处理机调度算法的模拟

Posted 之墨_

tags:

篇首语:本文由小常识网(cha138.com)小编为大家整理,主要介绍了操作系统实验—处理机调度算法的模拟相关的知识,希望对你有一定的参考价值。

操作系统实验—处理机调度算法的模拟

一、实验目的:

熟悉处理器调度算法的工作原理,掌握调度算法的实现、进程的状态及状态转换。具体如下:

  1. 设计并实现模拟进程调度的算法:时间片轮转调度算法。
  2. 理解进程控制块的结构。
  3. 理解进程运行的并发性。
  4. 掌握进程调度算法。

二、实验内容:

在多道程序运行环境下,进程数目一般多于处理机数目,使得进程要通过竞争来使用处理机。这就要求系统能按某种算法,动态地把处理机分配给就绪队列中的一个进程,使之运行,分配处理机的任务是由进程调度程序完成的。一个进程被创建后,系统为了便于对进程进行管理,将系统中的所有进程按其状态,将其组织成不同的进程队列。于是系统中有运行进程队列、就绪队列和各种事件的进程等待队列。进程调度的功能就是从就绪队列中挑选一个进程到处理机上运行。进程调度的算法有多种,常用的有优先级调度算法、先来先服务算法、时间片轮转算法。
进程是程序在处理机上的执行过程。进程存在的标识是进程控制块

PCB进程控制块结构

typedef struct PCB 
 
   int id;                            /* 进程id */
   char name[10];                    /* 进程标识符 */ 
   int allTime;                       /* 进程共需要占用 CPU 时间 */ 
   int needTime;                      /* 进程到完成还需要的时间 */ 
   int cpuTime;                      /* 进程已经占用CPU的时间 */
   int startBlock;                      /* 开始阻塞的时刻,-1表示不会发生阻塞*/
   int blockTime;                      /* 阻塞消耗的总时间 */
   char state;                        /* 进程的状态:就绪、阻塞、运行、完成*/ 
    struct node *next                   /*链指针*/ 
PCB; 

系统创建一个进程,就是由系统为某个程序设置一个PCB,用于对该进程进行控制和管理,进程任务完成,由系统收回其PCB,该进程便消亡。每个进程可以有四个状态:运行状态、就绪状态、阻塞状态和完成状态。
用C语言编写一个程序实现进程调度的算法,模拟进程调度的过程,加深对进程控制块概念和进程调度算法的理解。

设计要求:

  1. 进程的调度采用时间片轮转算法。
  2. 设计3个链队列,分别用来表示就绪队列、阻塞队列和完成队列。
  3. 进程的相关信息通过一个文本文件的形式传给程序,程序在接受到进程的信息后,为每个进程申请空间并存放进进程控制块PCB中。文本文件的内容自行设置。
  4. 为了清楚的观察各个进程的调度过程,每当有进程状态变化时,程序应该将所有进程当前的状态显示出来,一直到所有进程运行完成为止。具体参照如下的格式:

各个就绪进程的信息如下:

时间片轮转调度的基本原理:系统将所有就绪的进程按先来先服务的原则排成一个就绪队列。系统设置每一个时间间隔便产生一次中断,去激活进程调度程序进行调度,把CPU分配给队首进程,并令其执行一个时间片。当它运行完毕后,又把处理机分配给就绪队列中新的队首进程,也让它执行一个时间片。这样,就可以保证就绪队列中的所有进程在确定的时间段内,都能获得一个时间片的处理机时间。
在时间片轮转调度算法中,触发进程调度有如下几种情况:○1若一个时间片尚未用完,正在运行的进程便已经完成,就会立即激活调度程序,将它从就绪队列中删除,再调度就绪队列的队首进程运行。○2在一个时间片用完时,计时器中断处理程序被激活;如果进程尚未运行完毕,调度程序就把它送到就绪队列的末尾,再调度就绪队列的队首进程运行。○3进程在运行过程中遇到事件需要阻塞,这时即把该进程的状态由运行改为阻塞并置入事件阻塞队列末尾,然后激活调度程序,调度就绪队列的队首进程运行。○4在进程的阻塞事件完成后,向系统发送阻塞完成的信息,系统在收到相关信息后,就把该进程从阻塞队列中删除并置入就绪队列末尾。

三、实验过程记录:

1、算法的思路

首先实现本算法需要用到PCB以及PCB队列两个主要数据结构,编写函数实现PCBQueue的增删以及输出,还要实现对PCB控制块赋值的代码。通过对文件的操作封装readFile方法,获取txt文件中的数据对PCBQueue初始化,根据要求格式化输出。最后根据时间片轮转调度算法对进程进行模拟操作,输出每次运行的结果。

2、主要数据结构

	PCB结构体
1.	typedef struct PCB
2.	 
3.	     int id;                            /* 进程id */
4.	     string name;                    /* 进程标识符 */
5.	     int allTime;                       /* 进程共需要占用 CPU 时间 */
6.	     int needTime;                      /* 进程到完成还需要的时间 */
7.	     int cpuTime;                      /* 进程已经占用CPU的时间 */
8.	     int startBlock;                      /* 开始阻塞的时刻,-示不会发生阻塞*/
9.	     int blockTime;                      /* 阻塞消耗的总时间 */
10.	     string state;/* 进程的状态:就绪、阻塞、运行、完成*/
11.	     int blockT=//已经阻塞的时间
12.	     PCB *next;                /*链指针*/
13.	  PCB;
PCB队列结构体
14.	 struct PCBQueue
15.	     PCB *head=NULL;
16.	     PCB *end=NULL;
17.	 ;
18.	 void addPCB(PCBQueue &q,PCB *next)
19.	     if(q.head==NULL)
20.	         q.head=q.end=next;
21.	         return;
22.	     
23.	     next->next=NULL;
24.	     q.end->next=next;
25.	     q.end=next;
26.	 
27.	 
28.	 PCB* deletePCBQueue(PCBQueue &q)
29.	     PCB *p=q.head;
30.	     if(q.head->next==NULL)
31.	         q.head=NULL;
32.	         q.end=NULL;
33.	     else
34.	         q.head=q.head->next;
35.	     
36.	     p->next=NULL;
37.	     return p;
38.	 
39.	 void PrintPCBQueue(PCBQueue &q)
40.	     if(q.head==NULL)
41.	         return;
42.	     PCB *p=q.head;
43.	     while(p!=q.end)
44.	         cout<<"id"<<p->id<<" -> ";
45.	         p=p->next;
46.	     
47.	     cout<<"id"<<p->id;
48.	 

主要数据结构为进程控制块PCB的结构体以及对他进行操作的函数

3、程序代码

1.	#include <iostream>
2.	#include <queue>
3.	#include <fstream>
4.	#define TIMESLICE 5
5.	using namespace std;
6.	
7.	typedef struct PCB
8.	
9.	    int id;                            /* 进程id */
10.	    string name;                    /* 进程标识符 */
11.	    int allTime;                       /* 进程共需要占用 CPU 时间 */
12.	    int needTime;                      /* 进程到完成还需要的时间 */
13.	    int cpuTime;                      /* 进程已经占用CPU的时间 */
14.	    int startBlock;                      /* 开始阻塞的时刻,-1表示不会发生阻塞*/
15.	    int blockTime;                      /* 阻塞消耗的总时间 */
16.	    string state;/* 进程的状态:就绪、阻塞、运行、完成*/
17.	    int blockT=0;//已经阻塞的时间
18.	    PCB *next;                /*链指针*/
19.	 PCB;
20.	struct PCBQueue
21.	    PCB *head=NULL;
22.	    PCB *end=NULL;
23.	;
24.	void addPCB(PCBQueue &q,PCB *next)
25.	    if(q.head==NULL)
26.	        q.head=q.end=next;
27.	        return;
28.	    
29.	    next->next=NULL;
30.	    q.end->next=next;
31.	    q.end=next;
32.	
33.	
34.	PCB* deletePCBQueue(PCBQueue &q)
35.	    PCB *p=q.head;
36.	    if(q.head->next==NULL)
37.	        q.head=NULL;
38.	        q.end=NULL;
39.	    else
40.	        q.head=q.head->next;
41.	    
42.	    p->next=NULL;
43.	    return p;
44.	
45.	void PrintPCBQueue(PCBQueue &q)
46.	    if(q.head==NULL)
47.	        return;
48.	    PCB *p=q.head;
49.	    while(p!=q.end)
50.	        cout<<"id"<<p->id<<" -> ";
51.	        p=p->next;
52.	    
53.	    cout<<"id"<<p->id;
54.	
55.	PCB initialize(int id,string name,int allTime,int needTime,int cpuTime,int startBlock,int blockTime,string state,struct PCB *next)
56.	    PCB p;
57.	    p.id=id;
58.	    p.name=name;
59.	    p.allTime=allTime;
60.	    p.needTime=needTime;
61.	    p.cpuTime=cpuTime;
62.	    p.startBlock=startBlock;
63.	    p.blockTime=blockTime;
64.	    p.state=state;
65.	    p.next=next;
66.	    p.blockT=0;
67.	    return p;
68.	
69.	void readFile(PCB p[6])
70.	    ifstream outfile("C:\\\\Users\\\\社会人\\\\Desktop\\\\操作系统\\\\data.txt");
71.	    int id;string name;int allTime;int needTime;int cpuTime;int startBlock;int blockTime;string state;
72.	    int time=0;
73.	    while(outfile>>id>>name>>allTime>>needTime>>cpuTime>>startBlock>>blockTime>>state)
74.	        p[time]=initialize(id,name,allTime,needTime,cpuTime,startBlock,blockTime,state,NULL);
75.	        time++;
76.	    
77.	    outfile.close();
78.	
79.	void printFirstPCB(PCB p[6],PCBQueue readPCB)
80.	    cout<<"程序开始:"<<endl;        /* 用整数表示的时间,开始时为0 */
81.	    cout<<"当前时间:"<<0<<endl;
82.	    cout<<"各个就绪进程的信息如下:"<<endl;
83.	    cout<<"就绪队列:";
84.	    PrintPCBQueue(readPCB);
85.	    cout<<endl;  /* 显示就绪队列所有的进程,假设系统开始有6个进程 */
86.	    cout<<"========================================================================"<<endl;
87.	    cout<<" id name allTime needTime cpuTime startBlock blockTime state"<<endl;
88.	    cout<<"------------------------------------------------------------------------"<<endl;
89.	    for(int i=0;i<6;i++)
90.	        printf("  %d\\t %s\\t\\t\\t%d\\t\\t%d\\t\\t\\t%d\\t\\t%d\\t\\t\\t%d\\t\\t%s\\n",p[i].id,p[i].name.c_str(),p[i].allTime,p[i].needTime,p[i].cpuTime,p[i].startBlock,p[i].blockTime,p[i].state.c_str());
91.	    
92.	    cout<<"------------------------------------------------------------------------"<<endl;
93.	
94.	void printPCB(PCB p[6],int t,int m,PCBQueue readPCB,PCBQueue blockPCB,PCBQueue completPCB)
95.	    cout<<"第"<<t<<"次有程序状态变化:"<<endl;
96.	    cout<<"当前时间:"<<m<<endl;        /* 用整数表示的时间,开始时为0 */
97.	    cout<<"运行状态程序:id, name, allTime, needTime, cpuTime, startBlock, blockTime, state"<<endl;
98.	    cout<<"就绪队列:";
99.	    PrintPCBQueue(readPCB);/* 显示就绪队列所有的进程 */
100.	    cout<<endl;
101.	    cout<<"阻塞队列:";
102.	    PrintPCBQueue(blockPCB);
103.	    cout<<endl;
104.	    /* 显示阻塞队列所有的进程 */
105.	    cout<<"完成队列:";
106.	    PrintPCBQueue(completPCB);/* 显示完成队列所有的进程 */
107.	    cout<<endl;
108.	    cout<<"========================================================================"<<endl;
109.	    cout<<" id name allTime needTime cpuTime startBlock blockTime state"<<endl;
110.	    cout<<"------------------------------------------------------------------------"<<endl;
111.	    for(int i=0;i<6;i++)
112.	        printf("  %d\\t %s\\t\\t\\t%d\\t\\t%d\\t\\t\\t%d\\t\\t%d\\t\\t\\t%d\\t\\t%s\\n",p[i].id,p[i].name.c_str(),p[i].allTime,p[i].needTime,p[i].cpuTime,p[i].startBlock,p[i].blockTime,p[i].state.c_str());
113.	    
114.	    cout<<"------------------------------------------------------------------------"<<endl;
115.	
116.	void SchedulingAlgorithm(PCB p[6],int m,int t,PCBQueue readPCB,PCBQueue blockPCB,PCBQueue completPCB)
117.	    PCB *readp=NULL;
118.	    bool flag;
119.	    int readTime;
120.	    while(readPCB.head!=NULL||blockPCB.head!=NULL)
121.	        if(readPCB.head==NULL)
122.	            PCB *blockP=deletePCBQueue(blockPCB);
123.	            m+=blockP->blockTime-blockP->blockT;
124.	            blockP->blockT=0;
125.	            blockP->state="READY";
126.	            addPCB(readPCB,blockP);
127.	            printPCB(p,t++,m,readPCB,blockPCB,completPCB);
128.	        
129.	        if(readPCB.head!=NULL)
130.	            readp=deletePCBQueue(readPCB);
131.	            readp->state="RUNNING";
132.	            printPCB(p,t++,m,readPCB,blockPCB,completPCB);
133.	            flag=false;
134.	            readTime=0;
135.	            if(readp->startBlock!=-1)
136.	                if(readp->startBlock<=TIMESLICE)
137.	                    if(readp->needTime<=readp->startBlock)//运行完
138.	                        readTime+=readp->needTime;
139.	                        m+=readp->needTime;
140.	                        readp->cpuTime+=readp->needTime;
141.	                        readp->needTime=0;
142.	                        readp->state="FINISHED";
143.	                        addPCB(completPCB,readp);
144.	                        printPCB(p,t++,m,readPCB,blockPCB,completPCB);
145.	                    else//阻塞
146.	                        readTime+=readp->startBlock;
147.	                        m+=readp->startBlock;
148.	                        readp->cpuTime+=readp->startBlock;
149.	                        readp->needTime-=readp->startBlock;
150.	                        readp->state="BLOCKED";
151.	                        readp->startBlock=-1;
152.	                    
153.	                else
154.	                    flag=true;
155.	            else
156.	                flag=true;
157.	            if(flag)//正常运行
158.	                if(readp->needTime<=TIMESLICE)//运行完
159.	                    readTime+=readp->needTime;
160.	                    m+=readp->needTime;
161.	                    readp->cpuTime+=readp->needTime;
162.	                    readp->needTime=0;
163.	                    readp->state="FINISHED";
164.	                    addPCB(completPCB,readp);
165.	                    printPCB(p,t++,m,readPCB,blockPCB,completPCB);
166.	                else//没有运行完
167.	                    readTime+=TIMESLICE;
168.	                    readp->cpuTime+=TIMESLICE;
169.	                    readp->needTime-=TIMESLICE;
170.	                    readp->state="READY";
171.	                    m+=TIMESLICE;
172.	                    addPCB(readPCB,readp);
173.	                    printPCB(p,t++,m,readPCB,blockPCB,completPCB);
174.	                
175.	            
176.	        
177.	        while(blockPCB.head!=NULL&&readp!=NULL)
178.	            PCB *blockP=deletePCBQueue(blockPCB);
179.	            if(readTime==0)
180.	                break;
1

以上是关于操作系统实验—处理机调度算法的模拟的主要内容,如果未能解决你的问题,请参考以下文章

操作系统实验二(调度算法模拟-先进先出-时间片轮转法-优先服务调度算法)

模拟实现银行家调度算法

实验进程调度模拟程序

进程调度模拟程序

操作系统实验1:处理机调度

处理器调度算法的实现