模拟进程调度

最新推荐文章于 2023-02-02 11:28:44 发布
最新推荐文章于 2023-02-02 11:28:44 发布
阅读量1.1k 收藏 6
点赞数
分类专栏： c++ 文章标签： 进程调度
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/fenrir1205/article/details/8748565
版权

通过C++编程来模拟三种进程调度方式：FCFS（先来先服务），Priority Scheduling（优先度调度）和Multilever feedback queue （多级反馈队列）

现有5个进程同时一次进入进程调度器

进程名时间花销优先度
P1103
P211
P323
P414
P552

多级反馈队列中，第一级的时间片是1，第二级是2.....以此类推



模拟进程调度程序说明

 

两个结构

首先介绍两个数据结构

Process结构：

structProcess

{

    char name[NAME_LENGTH];//进程名字

    int priority;//优先度

    int cost;//进程执行需要时间开销

    int used;//已用时间

    int wait_time;//等待时间

    Process(char na[],int ct,int prio)

    {

        strcpy(name,na);

        cost = ct;

        priority = prio;

        wait_time = 0;

        used = 0;

    }

    void print()

    {

        printf("Process Name:%s \tPriorityValue:%d \tWaiting time:%d\n",name,priority,wait_time);

    }

};

这个结构用来保存进程信息。

然后通过创建一个Process指针数组来保存要处理的进程

    Process *process_list[PROCESS_NUM];

    process_list[0]=newProcess("P1",10,3);

    process_list[1]=newProcess("P2",1,1);

    process_list[2]=newProcess("P3",2,3);

    process_list[3]=newProcess("P4",1,4);

process_list[4]=new Process("P5",5,2);

MultiQueue结构：

struct MultiQueue

{

   queue<Process *> plist;//该级的队列

   int quantum_time;//该级别的时间片

   int lever;//记录级别

   MultiQueue *next;//下一级队列

   MultiQueue()

    {

       lever = 0;

       next = NULL;

       quantum_time = 0;

       while(!plist.empty())

           plist.pop();

    }

};

这个多级队列结构是服务于多级反馈队列进程调度服务的。

一个MultiQueue就是一个多级反馈队列。

quantum_time定义了该级别的时间片

plist则是保存了在这个级别队列里面的待运行进程

lever记录当前是第几个级别的

 

三个方法

由于要模拟先到先服务（FIFO/FCFS）、优先数调度（Priority Scheduling）和多级反馈队列调度（Multilevel feedback queue），所以我实现了三个方法分别表示这三种调度方法，每一个方法的参数都是待调度进程数组和数组规模。也就是上文利用Process创建的指针数组Process *process_list[PROCESS_NUM].

First Come,First Served方法

//First Come,First Served 先来先服务 ，即FIFO，First In，First Out

void FCFS(Process* plist[],int psize)

{

   printf("First Come First Served running...\n");

   queue< Process * > fcfs_list;

   while(!fcfs_list.empty())fcfs_list.pop();

   for (int i=0;i<psize;i++)

    {

       fcfs_list.push(plist[i]);

    }

   int time =0;

   while(!fcfs_list.empty())

    {

       Process * excu = fcfs_list.front();

       fcfs_list.pop();

       excu->wait_time = time;

       time += excu->cost;

       printf("%s excute %d timeunits...\n",excu->name,excu->cost);

    }

   printf("First Come First Served ending...\n");

   time = 0;

   for (int i=0;i<psize;i++)

    {

       plist[i]->print();

       time += plist[i]->wait_time;

    }

   double mwt = (double)time/psize;

   printf("Mean Waiting Time is %.2lf\n",mwt);

   printf("------------------------\n");

}

首先创建一个队列fcfs_list表示FCFS的待执行进程。然后按照plist[]的顺序把进程压进fcfs_list里面。接着就开始执行进程。

每次执行从fcfs_list取出最前面的进程，此时时间累加器time即为此进程的等待时间，并把该进程的执行时间累加紧time里面。一直执行直到fcfs_list为空。

这时每一个进程任务都已经执行完毕了，最后可以通过访问每一个进程的plist[i]->wait_time来得到平均等待时间并打印出来

Priority Scheduling方法

//Priority Scheduling优先数调度法，非抢占式

void PS(Process* plist[],int psize)

{

   printf("Priority Scheduling running...\n");

   //因为优先度调度需要根据优先度对进程进行排序后放进队列，为了不影响原顺序，用一个新的数组来暂存排序结果

   Process* sort_list[PROCESS_NUM];

   for (int i=0;i<psize;i++)

    {

       sort_list[i] = plist[i];

    }

   sort_priority(sort_list,psize);

   queue< Process * > ps_list;

   while(!ps_list.empty())

       ps_list.pop();

   for (int i=0;i<psize;i++)

    {

       ps_list.push(sort_list[i]);

    }

   int time =0;

   while(!ps_list.empty())

    {

       Process * excu = ps_list.front();

       ps_list.pop();

       excu->wait_time = time;

       time += excu->cost;

       printf("%s excute %d timeunits...\n",excu->name,excu->cost);

    }

   printf("Priority Scheduling ending...\n");

    time = 0;

   for (int i=0;i<psize;i++)

    {

       plist[i]->print();

       time += plist[i]->wait_time;

    }

   double mwt = (double)time/psize;

   printf("Mean Waiting Time is %.2lf\n",mwt);

   printf("------------------------\n");

}

由于优先数调度是根据每一个进程的优先数来判定进程的执行顺序，优先数越小，越早执行。

所以要先对进程进行一个优先数升序排序。为了不影响原进程数组的顺序。这里新建了一个plist[]的副本sort_list[]，然后对sort_list[]进行升序排序，最后把sort_list[]排序后的结果按顺序压进优先数调度队列ps_list里面。

接着就开始执行进程。

每次执行从ps_list取出最前面的进程，此时时间累加器time即为此进程的等待时间，并把该进程的执行时间累加紧time里面。一直执行直到ps_list为空。

这时每一个进程任务都已经执行完毕了，最后可以通过访问每一个进程的plist[i]->wait_time来得到平均等待时间并打印出来

Multilevel feedback queue方法

//Multilevel feedback queue多级反馈队列调度

void MFQ(Process* plist[],int psize)

{

   printf("Multilevel feedback queue running...\n");

   MultiQueue *mq = new MultiQueue();

   MultiQueue *current;

   mq->quantum_time = 1;

   mq->lever = 1;

   for (int i=0;i<psize;i++)

    {

       plist[i]->used = 0;

       mq->plist.push(plist[i]);

    }

 

   int time = 0;

   current = mq;

   //只有没有下一级队列并且当前队列为空时，才退出

   while(! (current->plist.empty() && current->next==NULL))

    {

       if (current->plist.empty())

           current = current->next;

       else

       {

           Process * excu = current->plist.front();

           current->plist.pop();

           int todo_time = excu->cost - excu->used;

           if (todo_time > current->quantum_time )

           {

                todo_time =current->quantum_time;

                excu->used += todo_time;

                if (current->next==NULL)

                {

                    current->next = newMultiQueue();

                   current->next->quantum_time = current->quantum_time+1;

                    current->next->lever= current->lever+1;

                }

               current->next->plist.push(excu);

            }else

           {

                excu->wait_time = time -excu->used;

                excu->used += todo_time;

           }

           time += todo_time;

           printf("%s excute %d time units at %dlayer...\n",excu->name,todo_time,current->lever);

       }

    }

   printf("Multilevel feedback queue ending...\n");

   time = 0;

   for (int i=0;i<psize;i++)

    {

       plist[i]->print();

       time += plist[i]->wait_time;

    }

   double mwt = (double)time/psize;

   printf("Mean Waiting Time is %.2lf\n",mwt);

   printf("------------------------\n");

 

}

多级反馈队列把进程划分到多个级别里面执行，每一个级别的队列给与进程有限的运行时间，若所给时间内还没有执行完毕，则弹出此进程并把此进程放置到下一级进程里面继续执行。

而一般下一级队列要比上一级队列的能给与时间片要长。也就是说，如果第一级队列的时间片为1，时间片时间内不能完成，则弹到第二级队列执行，第二级的队列时间片可能就为2，以此类推。

在MFQ方法里面也是这么运作的。首先创建一个多级队列MultiQueue *mq = new MultiQueue()，用MultiQueue *current指示当前级别队列。一开始把所有进程压进mq->plist里面，也就是压进第一级的队列里面。然后开始执行进程

每执行一个进程，首先判断该进程还需要执行的时间能否在当前级别的时间片内完成，能完成则该进程的等待时间为excu-> wait_time = 当前时间time-该进程已用时间excu->used ；若是不能在该时间片内完成，则把此进程使用世家加上该级别的时间片世家todo_time = current->quantum_time;excu->used += todo_time;由于此进程仍需要执行，需要压进下一级的队列里面待执行，所以先检查下一级队列是否存在，不存在则创建下一级队列，然后压进下一级队列里面。

以上操作完成了就表示该进程在此级别里面的操作结束了。把该进程的使用时间todo_time 加到时间累加器time里面表示时间的使用time += todo_time;

一直重复这操作直到该级别的队列为空。若是下一级别队列不为空，则把当前队列指针移到下一级队列里面if (current->plist.empty())   current = current->next; 否则就表示所有进程都执行完毕了。

最后可以通过访问每一个进程的plist[i]->wait_time来得到平均等待时间并打印出来

附录

源代码

//Process Scheduling (Simulation)
/*
author:黎伟杰
*/
#include <iostream>
#include <cstdio>
#include <cstring>
#include <queue>
#include <algorithm>

using namespace std;

#define NAME_LENGTH 255
#define PROCESS_NUM 5

struct Process
{
    char name[NAME_LENGTH];//进程名字
    int priority;//优先度
    int cost;//进程执行需要时间开销
    int used;//已用时间
    int wait_time;//等待时间
    Process()
    {
        wait_time = 0;
        used = 0;
    }
    Process(char na[],int ct,int prio)
    {
        strcpy(name,na);
        cost = ct;
        priority = prio;
        wait_time = 0;
        used = 0;
    }
    Process(Process &rhs)
    {
        strcpy(name,rhs.name);
        cost = rhs.cost;
        priority = rhs.priority;
        wait_time = rhs.wait_time;
        used = rhs.used;
    }
    void init(char na[],int ct,int prio)
    {
        strcpy(name,na);
        cost = ct;
        priority = prio;
        wait_time = 0;
        used = 0;
    }
    void print()
    {
        printf("Process Name:%s \tPriority Value:%d \tWaiting time:%d\n",name,priority,wait_time);
    }
};



void sort_priority(Process* plist[],int psize)
{
    int i = psize-1;
    Process *tmp;
    while(i>=0)
    {
        for (int j=0;j<i;j++)
        {
            if (plist[i]->priority<plist[j]->priority)
            {
                tmp = plist[i];
                plist[i] = plist[j];
                plist[j] = tmp;
            }
        }
        i--;
    }
}

//First Come,First Served 先来先服务 ，即FIFO，First In，First Out
void FCFS(Process* plist[],int psize)
{
    printf("First Come First Served running...\n");
    queue< Process * > fcfs_list;
    while(!fcfs_list.empty())fcfs_list.pop();
    for (int i=0;i<psize;i++)
    {
        fcfs_list.push(plist[i]);
    }
    int time =0;
    while(!fcfs_list.empty())
    {
        Process * excu = fcfs_list.front();
        fcfs_list.pop();
        excu->wait_time = time;
        time += excu->cost;
        printf("%s excute %d time units...\n",excu->name,excu->cost);
    }
    printf("First Come First Served ending...\n");
    time = 0;
    for (int i=0;i<psize;i++)
    {
        plist[i]->print();
        time += plist[i]->wait_time;
    }
    double mwt = (double)time/psize;
    printf("Mean Waiting Time is %.2lf\n",mwt);
    printf("------------------------\n");
}

//Priority Scheduling优先数调度法，非抢占式
void PS(Process* plist[],int psize)
{
    printf("Priority Scheduling running...\n");
    //因为优先度调度需要根据优先度对进程进行排序后放进队列，为了不影响原顺序，用一个新的数组来暂存排序结果
    Process* sort_list[PROCESS_NUM];
    for (int i=0;i<psize;i++)
    {
        sort_list[i] = plist[i];
    }
    sort_priority(sort_list,psize);
    queue< Process * > ps_list;
    while(!ps_list.empty())
        ps_list.pop();
    for (int i=0;i<psize;i++)
    {
        ps_list.push(sort_list[i]);
    }
    int time =0;
    while(!ps_list.empty())
    {
        Process * excu = ps_list.front();
        ps_list.pop();
        excu->wait_time = time;
        time += excu->cost;
        printf("%s excute %d time units...\n",excu->name,excu->cost);
    }
    printf("Priority Scheduling ending...\n");
    time = 0;
    for (int i=0;i<psize;i++)
    {
        plist[i]->print();
        time += plist[i]->wait_time;
    }
    double mwt = (double)time/psize;
    printf("Mean Waiting Time is %.2lf\n",mwt);
    printf("------------------------\n");
}

//多级队列，用链表实现
struct MultiQueue
{
    queue<Process *> plist;//该级的队列
    int quantum_time;//该级别的时间片
    int lever;//记录级别
    MultiQueue *next;//下一级队列
    MultiQueue()
    {
        lever = 0;
        next = NULL;
        quantum_time = 0;
        while(!plist.empty())
            plist.pop();
    }
};

//Multilevel feedback queue多级反馈队列调度
void MFQ(Process* plist[],int psize)
{
    printf("Multilevel feedback queue running...\n");
    MultiQueue *mq = new MultiQueue();
    MultiQueue *current;
    mq->quantum_time = 1;
    mq->lever = 1;
    for (int i=0;i<psize;i++)
    {
        plist[i]->used = 0;
        mq->plist.push(plist[i]);
    }

    int time = 0;
    current = mq;
    //只有没有下一级队列并且当前队列为空时，才退出
    while(! (current->plist.empty() && current->next==NULL))
    {
        if (current->plist.empty())
            current = current->next;
        else
        {
            Process * excu = current->plist.front();
            current->plist.pop();
            int todo_time = excu->cost - excu->used;
            if (todo_time > current->quantum_time )
            {
                todo_time = current->quantum_time;
                excu->used += todo_time;
                if (current->next==NULL)
                {
                    current->next = new MultiQueue();
                    current->next->quantum_time = current->quantum_time+1;
                    current->next->lever = current->lever+1;
                }
                current->next->plist.push(excu);
            }else
            {
                excu->wait_time = time - excu->used;
                excu->used += todo_time;
            }
            time += todo_time;
            printf("%s excute %d time units at %d layer...\n",excu->name,todo_time,current->lever);
        }
    }
    printf("Multilevel feedback queue ending...\n");
    time = 0;
    for (int i=0;i<psize;i++)
    {
        plist[i]->print();
        time += plist[i]->wait_time;
    }
    double mwt = (double)time/psize;
    printf("Mean Waiting Time is %.2lf\n",mwt);
    printf("------------------------\n");

}

int main()
{
    Process *process_list[PROCESS_NUM];
    process_list[0]=new Process("P1",10,3);
    process_list[1]=new Process("P2",1,1);
    process_list[2]=new Process("P3",2,3);
    process_list[3]=new Process("P4",1,4);
    process_list[4]=new Process("P5",5,2);
    FCFS(process_list,5);
    PS(process_list,5);
    MFQ(process_list,5);
    return 0;
}


fenrir1205
关注
  • 0
    点赞
  • 踩
  • 6
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
操作系统模拟进程调度算法C#Winfrom实现
12-25
操作系统课程设计，基于C#Winform窗体界面的。主要算法有：先来先服务、短作业优先以及优先级调度算法。
操作系统页面调度算法的模拟实现
AtalantaL的博客
11-30 1909
1.实验内容 输入： 进程的页面请求序列，即一系列页面号（页面号用整数表示，用空格作为分隔符），用来模拟待换入的页面。 下面是一个示意： 1 2 3 4 1 2 5 1 2 3 4 5 初始条件：采用三个空闲内存块，初始时均为空。 输出要求： 第一行：每次淘汰的页面号 第二行：显示缺页的总次数和缺页中断率。 2.实验类型 设计型。 3.实验目的和要求 页面调度（淘汰）算法主要有：FIFO，最近最少...
进程切换跳转实现 swtich_to
eric43的专栏
09-29 852
进程切换跳转实现 /* * switch_to(n)将切换当前任务到任务nr，即n。首先检测任务n 不是当前任务， * 如果是则什么也不做退出。如果我们切换到的任务最近（上次运行）使用过数学 * 协处理器的话，则还需复位控制寄存器cr0 中的TS 标志。 */ // 输入：%0 - 新TSS 的偏移地址(*&__tmp.a)； %1 - 存放新TSS 的选择符值(*&__tmp.b)；
操作系统模拟页面调度算法（OPT、FIFO、LRU）演示（vc6.0调试通过）
Kernel Main的专栏
05-05 3464
// PageSwitch.cpp : Defines the entry point for the console application. // #include "stdafx.h" /*******************************************************************/ //请分别用FIFO、OPT算法实现“页面置换”的模拟。模拟程序的
操作系统——四种进程调度算法模拟实现（C语言）
热门推荐
mcr1379673758的博客
05-03 4万+
操作系统——四种进程调度算法模拟实现（C语言）
PCD.rar_模拟进程_模拟进程调度
09-21
这它用C语言编写的实现模拟进程调度的程序，用户模拟几个进程，输入它们的进程名，优先级，运行时间等，进程的初使状态为就绪状态。然后就按优先级优先方式调度各个进程，进程的状态也因此会变成等待状态或完成状态...
模拟进程调度（GUI实现）
05-17
操作系统上机作业，模拟实现进程创建，进程调度，进程阻塞，进程唤醒和进程撤销，从文件读取初始化进程，将过程存入文件均已实现，用pyqt5实现GUI界面，有良好的用户交互性
java 模拟进程调度
12-15
在这个例子中，我实现了进程调度的三种算法，分别是优先级算法，时间片算法，和段作业优先算法。进程从文件中读取
c++实现进程调度的模拟
04-22
利用c++模拟进程的调度。模拟操作系统内核对进程的控制和管理：包括进程的创建和撤销、进程状态的切换和简单的内存空间管理。  能够模拟进程的创建与撤销过程；（4 分）  对进程的状态进行全面的控制；（4 分）  按先进先出方式管理就绪和阻塞队列，按队列输出进程状态 （2 分）  完成可变分区的分配与回收 （3 分）  界面清晰友好 （2 分）  实验结束后撰写实验报告（5 分）。
优先数调度算法
12-01
网络操作系统课程里涉及到的算法,不涉及到指针的用法，简单易懂实用
操作系统短作业优先进程调度算法
05-29
短作业优先进程调度算法 （1）用C语言（或其它语言，如Java）实现对N个进程采用某种进程调度算法（如动态优先权调度）的调度。 （2）每个用来标识进程的进程控制块PCB可用结构来描述，包括以下字段：  进程标识数ID。  进程优先数PRIORITY，并规定优先数越大的进程，其优先权越高。  进程已占用CPU时间CPUTIME。  进程还需占用的CPU时间ALLTIME。当进程运行完毕时，ALLTIME变为0。  进程的阻塞时间STARTBLOCK，表示当进程再运行STARTBLOCK个时间片后，进程将进入阻塞状态。  进程被阻塞的时间BLOCKTIME，表示已阻塞的进程再等待BLOCKTIME个时间片后，将转换成就绪状态。  进程状态STATE。  队列指针NEXT，用来将PCB排成队列。 （3）优先数改变的原则：  进程在就绪队列中呆一个时间片，优先数增加1。  进程每运行一个时间片，优先数减3。 （4）为了清楚地观察每个进程的调度过程，程序应将每个时间片内的进程的情况显示出来，包括正在运行的进程，处于就绪队列中的进程和处于阻塞队列中的进程。 （5）分析程序运行的结果，谈一下自己的认识。
进程调度模拟(C语言实现)
05-29
NULL 博文链接：https://touch-2011.iteye.com/blog/1047163
操作系统进程调度模拟算法
05-09
实验内容： 进程调度模拟程序：假设有10个进程需要在CPU上执行，分别用：  先进先出调度算法；  基于优先数的调度算法；  最短执行时间调度算法 确定这10个进程在CPU上的执行过程。要求每次进程调度时在屏幕上显示：  当前执行进程；  就绪队列；  等待队列 实验目的： 1）掌握处理机调度及其实现； 2）掌握进程状态及其状态转换； 3）掌握进程控制块PCB及其作用。 实验要求： 1） 创建10个进程的PCB，每个PCB包括：进程名、进程状态、优先级（1~10）、需要在处理机上执行的时间（ms）、队列指针等； 2） 初始化10个PCB（产生随机数0或1，分别表示进程处于就绪态或等待态）； 3） 根据调度算法选择一个就绪进程在CPU上执行； 4） 在进程执行过程中，产生随机数0或1，该随机数为1时，将等待队列中的第一个PCB加入就绪队列的对尾； 5） 在进程执行过程中，产生一个随机数，表示执行进程能在处理机上执行的时间，如果随机时间大于总需要的时间，则执行完成。如果小于，则从总时间中减去执行时间。 6） 如果执行进程没有执行完成。则产生随机数0或1，当该随机数为0时，将执行进程加入就绪队列对尾；否则，将执行进程加入等待队列对尾； 7） 一直到就绪队列为空，程序执行结束。
对3种进程调度算法进行模拟的小程序
舟
04-23 1875
3种进程调度算法：短作业优先，优先数算法，时间片轮转算法。 实现功能：从文本中读入5个作业，模拟作业调度，动态画出甘特图，计算各个作业的响应时间和周转时间。 其它：实现语言C++，创建的win32项目，面向对象思想，作者水平有限，望高手多多指点。 源代码托管地址（SVN-checkout）： http://proccess-schedule-simulator.googlecode.com
调度问题分类
m0_65532100的博客
02-02 859
顺序、调度和调度策略。
进程调度算法模拟
pp_517318的博客
11-14 5618
1、绪论 1.1 了解进程调度算法的特点 1.2熟悉进程结构体数组。 1.3 掌握进程调度算法：时间片轮转法（RR）、短进程优先法（SJF） 2、实验内容 2.1 设计C语言程序，模拟实现进程调度算法 2.1.1 时间片轮转法（RR） 将所有的就绪进程按先来先服务的原则排成一个队列，每次调度时，把处理机分配给队首进程，并令其执行一个时间片。 2.1.2 短进程优先法（SJF） 以进入系统的作业所要求的CPU运行时间的长短为挑选依据，优先选取预计所需服务时间最短的作业进行调度，可以分别用于.
python模拟进程调度
最新发布
05-10
在 Python 中模拟进程调度可以通过模拟进程的状态、优先级和时间片等来实现。 下面是一个简单的模拟进程调度的示例代码： ```python # 定义进程类 class Process: def __init__(self, pid, name, priority, burst...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值