实验2 进程调度

已于 2023-03-11 21:24:21 修改
阅读量161 收藏
点赞数
分类专栏： 操作系统实验 文章标签： c++ c语言 开发语言
于 2022-06-14 16:47:01 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_51998874/article/details/125055189
版权
本文档介绍了如何实现四种调度算法（PSA、FCFS、SJF和MFQ），包括优先级调度、先来先服务、短作业优先及多级反馈队列，通过C++代码展示了从数据输入到算法运行的全过程，包括进程创建、菜单选择、调度执行和性能统计。
摘要由CSDN通过智能技术生成 
#include<bits/stdc++.h>
#define W 1
#define R 2
#define F 3
#define PS 1
#define FCFS 2
#define SJF 3
#define MFQ 4
using namespace std;
const int maxn = 10+1;
const char State[maxn][maxn]={"0", "Wait", "Run", "Finish"};//进程状态
int choose;//用户选择
int TotPCB;//总进程个数
int NOWTIME;//模拟系统时间

typedef struct pcb
{
    char name[maxn];
    int priority, arriveTime, serveTime, AllCPUtime;
    //分别为优先级，就绪时间，服务时间，已占用进程时间
    int completeTime;
    int state;
}*PCB, pb;

typedef struct Pr//进程
{
    PCB Pcb;//该结点的代表的进程控制块
    Pr *nex;//该节点的下一个结点
}*PCBQ;//进程控制块队列

PCBQ DataQ;//读入的数据
PCBQ ReadyQ;//就绪队列
PCBQ PCBBank;;//还在系统中进程队列

void outmenu();//菜单

//以下是算法
bool PSA();//优先级调度算法
bool FCFSA();//先来先服务调度算法
bool SJFA();//短作业优先调度算法
bool MFQA();//多级反馈队列调度算法

//以下是操作
void Init();//初始化
void InsertPCB(PCBQ, PCB);//将PCB插入指定队列
PCBQ FindPCB();//在当前NOWTIME条件下在DataQ中寻找有没有新的进程到达
void DisPlay(PCB);//显示该进程的信息
void View(PCBQ);//显示该队列的信息
bool IsEmpty(PCBQ);//检查队列是否为空
void OutTimeConsume();//输出平均周转时间和带权平均周转时间
PCBQ Pop(PCBQ);

int main()
{
    freopen("data.in","r", stdin);
    Init();
    puts("请输入进程个数");
    scanf("%d", &TotPCB);
    puts("请分别输入这些进程的进程名、就绪时刻、服务时间、优先级");
    for(int i=1; i<=TotPCB; ++i)
    {
        PCB p = (PCB)malloc(sizeof(pb));
        scanf("%s %d %d %d", p->name, &p->arriveTime, &p->serveTime, &p->priority);
        p->AllCPUtime = 0;
        p->completeTime = -1;
        p->state = W;//初始没有
        InsertPCB(DataQ, p);
    }
    outmenu();
    View(DataQ);
    scanf("%d", &choose);
    while (choose>4||choose<1)
    {
        puts("请输入正确的算法编号");
        scanf("%d", &choose);
    }
    
    bool flag = false;
    switch (choose)
    {
    case PS:
        flag = PSA();
        break;
    case FCFS:
        flag = FCFSA();
        break;
    case SJF:
        flag = SJFA();
        break;
    case MFQ:
        flag = MFQA();
        break;
    default:
        puts("something wrong");
        break;
    }
    if(flag) puts("调用成功");
    else{
        puts("错误退出");
    }
    return 0;
}

void outmenu()
{
    puts("本调度系统均采用非抢占调度，以下是可供调度算法，请选择");
    puts("1.最高优先数优先算法\n2.先来先服务算法\n3.短作业优先算法\n4.多级反馈\n");
}

bool PSA()
{
    puts("现在在调用最高优先数优先算法\n");
    while (!IsEmpty(DataQ)||!IsEmpty(ReadyQ))//当没有进程再来的时候并且就绪队列进程都运行完就结束循环
    {
        //寻找当前系统时间有没有新进程到达
        PCBQ NewPCB;
		while((NewPCB = FindPCB()) != NULL)
        {           
			PCBQ node = (PCBQ)malloc(sizeof(Pr));
			node->Pcb = NewPCB->Pcb;
            node->nex = NULL;
            //按照当前的算法将新进程插入就绪队列
			PCBQ head = ReadyQ;
			while(head->nex&&node->Pcb->priority<=head->nex->Pcb->priority) head = head->nex;
            node->nex = head->nex;
            head->nex = node;
		}
        if(IsEmpty(ReadyQ)) ++NOWTIME;//模拟系统时间片
        else{
            //就绪队列不为空要进行调度
            PCBQ node = Pop(ReadyQ);
            node->Pcb->state = R;
            printf("进程%s信息入下\n", node->Pcb->name);
            DisPlay(node->Pcb);
            puts("");
            puts("就绪队列信息如下");
            View(ReadyQ);
            puts("");
            puts("各个进程的PCB如下");
            View(PCBBank);
            puts("");
            node->Pcb->state = F;
            node->Pcb->AllCPUtime += node->Pcb->serveTime;
            node->Pcb->completeTime = NOWTIME+node->Pcb->serveTime;
            NOWTIME += node->Pcb->serveTime;
        }
    }
    puts("结束以下是结果");
    View(PCBBank);
    OutTimeConsume();
    return true;
}

bool FCFSA()
{
    puts("现在在调用先来先服务算法");
     while (!IsEmpty(DataQ)||!IsEmpty(ReadyQ))//当没有进程再来的时候并且就绪队列进程都运行完就结束循环
    {
        //寻找当前系统时间有没有新进程到达
        PCBQ NewPCB;
		while((NewPCB = FindPCB()) != NULL)
        {
			PCBQ node = (PCBQ)malloc(sizeof(Pr));
			node->Pcb = NewPCB->Pcb;
            node->nex = NULL;
            //按照当前的算法将新进程插入就绪队列
            PCBQ head = ReadyQ;
            while (head->nex) head = head->nex;
            head->nex = node;
		}

        if(IsEmpty(ReadyQ)) ++NOWTIME;//模拟系统时间片
        else{
            //就绪队列不为空要进行调度
            PCBQ node = Pop(ReadyQ);
            node->Pcb->state = R;
            printf("进程%s信息入下\n", node->Pcb->name);
            DisPlay(node->Pcb);
            puts("");
            puts("就绪队列信息如下");
            View(ReadyQ);
            puts("");
            puts("各个进程的PCB如下");
            View(PCBBank);
            puts("");
            node->Pcb->state = F;
            node->Pcb->AllCPUtime += node->Pcb->serveTime;
            node->Pcb->completeTime = NOWTIME+node->Pcb->serveTime;
            NOWTIME += node->Pcb->serveTime;
        }
    }
    puts("结束以下是结果");
    View(PCBBank);
    OutTimeConsume();
    return true;
}

bool SJFA()
{
    puts("现在在调用短作业优先算法");
     while (!IsEmpty(DataQ)||!IsEmpty(ReadyQ))//当没有进程再来的时候并且就绪队列进程都运行完就结束循环
    {
        //寻找当前系统时间有没有新进程到达
        PCBQ NewPCB;
		while((NewPCB = FindPCB()) != NULL)
        {
			PCBQ node = (PCBQ)malloc(sizeof(Pr));
			node->Pcb = NewPCB->Pcb;
            node->nex = NULL;
            //按照当前的算法将新进程插入就绪队列
			PCBQ head = ReadyQ;
			while(head->nex&&node->Pcb->serveTime>=head->nex->Pcb->serveTime) head = head->nex;
            node->nex = head->nex;
            head->nex = node;
		}

        if(IsEmpty(ReadyQ)) ++NOWTIME;//模拟系统时间片
        else{
            //就绪队列不为空要进行调度
            PCBQ node = Pop(ReadyQ);
            node->Pcb->state = R;
            printf("进程%s信息入下\n", node->Pcb->name);
            DisPlay(node->Pcb);
            puts("");
            puts("就绪队列信息如下");
            View(ReadyQ);
            puts("");
            puts("各个进程的PCB如下");
            View(PCBBank);
            puts("");
            node->Pcb->state = F;
            node->Pcb->AllCPUtime += node->Pcb->serveTime;
            node->Pcb->completeTime = NOWTIME+node->Pcb->serveTime;
            NOWTIME += node->Pcb->serveTime;
        }
    }
    puts("结束以下是结果");
    View(PCBBank);
    OutTimeConsume();
    return true;
}

bool MFQA()
{
    puts("现在在调用多级反馈队列算法");
    //因为使用多级反馈，所以还要再增加两个，而ReadQ已经初始化完成那么
    //新的就绪队列和ReadQ一样就可以
    PCBQ ReadyQ2 = (PCBQ)malloc(sizeof(Pr));
    PCBQ ReadyQ3 = (PCBQ)malloc(sizeof(Pr));
    ReadyQ2->Pcb = ReadyQ3->Pcb = ReadyQ->Pcb = NULL;
    ReadyQ3->nex = ReadyQ2->nex = ReadyQ->nex = NULL;

    while (!IsEmpty(DataQ)||!IsEmpty(ReadyQ)||!IsEmpty(ReadyQ2)||!IsEmpty(ReadyQ3))//当没有进程再来的时候并且就绪队列进程都运行完就结束循环
    {
        //寻找当前系统时间有没有新进程到达
        PCBQ NewPCB;
		while((NewPCB = FindPCB()) != NULL)
        {
			PCBQ node = (PCBQ)malloc(sizeof(Pr));
			node->Pcb = NewPCB->Pcb;
            node->nex = NULL;
            //按照当前的算法将新进程插入就绪队列
			PCBQ head = ReadyQ;
			while(head->nex&&node->Pcb->priority<=head->nex->Pcb->priority) head = head->nex;
            node->nex = head->nex;
            head->nex = node;
		}
        //队列时间片设置123
        if(IsEmpty(ReadyQ)&&IsEmpty(ReadyQ2)&&IsEmpty(ReadyQ3)) ++NOWTIME;//模拟系统时间片
        else{
            //就绪队列不为空要进行调度
            PCBQ node = NULL;
            int time = 0;
            if(!IsEmpty(ReadyQ)){
                time = 1;
                node = Pop(ReadyQ);
            }
            else if(!IsEmpty(ReadyQ2)){
                time = 2;
                node = Pop(ReadyQ2);
            }
            else if(!IsEmpty(ReadyQ3)){
                time = 3;
                node = Pop(ReadyQ3);
            }
            node->Pcb->state = R;
            printf("进程%s信息入下\n", node->Pcb->name);
            DisPlay(node->Pcb);
            puts("");
            puts("就绪队列1信息如下");
            View(ReadyQ);
            puts("");
            puts("就绪队列2信息如下");
            View(ReadyQ2);
            puts("");
            puts("就绪队列3信息如下");
            View(ReadyQ3);
            puts("");
            puts("各个进程的PCB如下");
            View(PCBBank);
            puts("");
            cout<<"time1 = "<<time<<endl;
            int rest = node->Pcb->serveTime-node->Pcb->AllCPUtime;
            if(rest>=time) node->Pcb->AllCPUtime += time, NOWTIME += time;
            else node->Pcb->AllCPUtime += rest, NOWTIME += rest;
            if(node->Pcb->AllCPUtime==node->Pcb->serveTime){
                node->Pcb->completeTime = NOWTIME;
                node->Pcb->state = F;
            }
            if(node->Pcb->state==F) continue;
            node->Pcb->state = W;
            // cout<<"time1 = "<<time<<endl;
            switch (time)
            {
            case 1:
                InsertPCB(ReadyQ2, node->Pcb);
                break;
            case 2:
                InsertPCB(ReadyQ3, node->Pcb);
                break;
            case 3:
                InsertPCB(ReadyQ3, node->Pcb);
                break;
            default:
                puts("something wrong in MFQA");
                puts("请联系作者来解决");
                return false;
                break;
            }
        }
    }
    View(PCBBank);
    OutTimeConsume();
    return true;
}

void Init(){
    //方便操作建立表头结点
    PCBBank = (PCBQ)malloc(sizeof(Pr));
	PCBBank->nex = NULL;
	PCBBank->Pcb = NULL;
	ReadyQ = (PCBQ)malloc(sizeof(Pr));
	ReadyQ->nex = NULL;
	ReadyQ->Pcb = NULL;
    DataQ = (PCBQ)malloc(sizeof(Pr));
    DataQ->nex = NULL;
    DataQ->Pcb = NULL;
	NOWTIME = 0;
}

void InsertPCB(PCBQ q, PCB node)
{
    PCBQ head = q;
    while (head->nex) head = head->nex;
    PCBQ t = (PCBQ)malloc(sizeof(Pr));
    t->Pcb = node;
    t->nex = NULL;
    head->nex = t;
}

PCBQ FindPCB()
{
    PCBQ head = DataQ;
    PCBQ ret = NULL;
    if(head->nex && head->nex->Pcb->arriveTime<=NOWTIME)
    {
        ret = (PCBQ)malloc(sizeof(Pr));
        ret->Pcb = head->nex->Pcb;
        ret->nex = NULL;
        InsertPCB(PCBBank, ret->Pcb);
        PCBQ t = head->nex;
        head->nex = t->nex;
        free(t);
    }
    return ret;
}

void DisPlay(PCB node){
    printf("进程名:%s 优先级:%d 到达时间:%d 需要服务时间:%d 完成时间:%d 状态:%s\n", 
    node->name, node->priority, 
    node->arriveTime, node->serveTime, 
    node->completeTime, State[node->state]);
}

void View(PCBQ head){
    PCBQ node = head;
    if(node->nex == NULL){
        puts("该就绪队列暂时为空");
        return;
    }
    puts("进程名  优先级  到达时间  需要服务时间  完成时间  状态  ");
    while (node->nex)
    {
        printf("%-7s %-7d %-9d %-13d %-9d %-8s\n", 
        node->nex->Pcb->name, node->nex->Pcb->priority, 
        node->nex->Pcb->arriveTime, node->nex->Pcb->serveTime, 
        node->nex->Pcb->completeTime, State[node->nex->Pcb->state]);
        node = node->nex;
    } 
}

bool IsEmpty(PCBQ head){
    return head->nex==NULL;
}

void OutTimeConsume()
{
    double t = 0, w = 0;
    PCBQ q = PCBBank;
    while (q->nex)
    {
        t += q->nex->Pcb->completeTime-q->nex->Pcb->arriveTime;
        w += (q->nex->Pcb->completeTime-q->nex->Pcb->arriveTime)*1.0/(1.0*q->nex->Pcb->serveTime);
        q = q->nex;
    }
    t /= (1.0*TotPCB);
    w /= (1.0*TotPCB);
    printf("平均周转时间为:%f 带权平均周转时间为:%f\n", t, w);
}

PCBQ Pop(PCBQ head)
{
    PCBQ ret = (PCBQ)malloc(sizeof(Pr));
	PCBQ p = head->nex;
	if(p){
		head->nex = p->nex;
		ret->Pcb = p->Pcb;
        ret->nex = NULL;
		free(p);
	}
	return ret;
}
VIHWINE
关注
专栏目录
进程调度实验
wxwlll的专栏
01-16 4676
实验目的 进程调度是处理机管理的核心内容。本实验要求用C语言编写和调试一个简单的进程调度程序。通过本实验可以加深理解有关进程控制块、进程队列的概念，并体会和了解优先数和时间片轮转调度算法的具体实施办法。 一、实验内容 实验内容（优先数和时间片轮转调度算法） ①设计进程控制块PCB表结构，分别适用于优先数调度算法和时间轮转调度算法。 ②建立进程就绪队列。对两种不同算法编制入链子程序。 ③
实验二、进程调度模拟实验
qq_44721518的博客
06-12 893
import java.util.ArrayList; import java.util.Collections; import java.util.Comparator; import java.util.LinkedHashSet; import java.util.LinkedList; import java.util.Queue; import java.util.Scanner; import com.sun.jndi.url.iiopname.iiopnameURLContextFact.
操作系统 | 实验二 进程调度
猫天意的博客
04-19 5075
①理解有关进程控制块、进程队列的概念。 ②掌握进程优先权调度算法和时间片轮转调度算法的处理逻辑。①设计进程控制块PCB的结构，分别适用于优先权调度算法和时间片轮转调度算法。 ②建立进程就绪队列。 ③编制两种进程调度算法：优先权调度和时间片轮转调度。1.数据结构 1、枚举类型 enum state { ready, // 准备 execute, //执行 block, //阻塞 finish //完成 };//定义进程状态2、结构体变量 //定义进程PCB struct pcb { char name[4];
操作系统实验二  进程调度
雪之下
05-19 8153
实验二 进程调度 一．目的和要求 通过这次实验，理解进程调度的过程，进一步掌握进程状态的转变、进程调度的策略，进一步体会多道程序并发执行的特点，并分析具体的调度算法的特点，掌握对系统性能的评价方法。 二．实验内容 阅读教材《计算机操作系统》第二章和第三章，掌握进程管理及调度相关概念和原理。 编写程序模拟实现进程的轮转法调度过程，模拟程序只对PCB进行相应的调度模拟操作，不需要实际程序。...
操作系统实验2进程调度
Wjy2016的博客
12-13 4471
[cpp] view plain copy #include      #include           struct node     {         int pid;//进程id号          int prio;//进程优先级          int runtime;//进程运行的时间          int alltime;//
ucos-II 任务调度源码分析（二）
Fred's Note
01-23 633
在ucos-II中最主要的函数是： INT8U OSTaskCreate (void (*task)(void *p_arg),void *p_arg,OS_STK *ptos, INT8U prio) *task:任务函数的钩子；*p_arg:任务的参数；ptos:指向任务的堆栈；prio:任务的优先级。 在OSTaskCreate中主要完成了以下工作： OSTCBPrioTbl[pr...
单片机中段程序_单片机c语言中的一小段程序解读
weixin_30495469的博客
01-14 207
函数名称：System_CalculateSolubility()函数功能：采样ADC0832的电压值，换算成浮点数溶度值*****************************************************************************/unsig...函数名称：System_CalculateSolubility()函数功能：采样ADC0832的电压值，换...
操作系统进程调度实验
11-13
进程调度模拟程序：假设有10个进程需要在CPU上执行，分别用： 先进先出调度算法； 基于优先数的调度算法； 最短执行时间调度算法 确定这10个进程在CPU上的执行过程。要求每次进程调度时在屏幕上显示： 当前...
操作系统模拟进程调度实验报告java_操作系统实验2进程调度实验报告.doc
weixin_33176326的博客
02-25 2492
操作系统实验2进程调度实验报告佛山科学技术学院实 验 报 告课程名称 操作系统原理实验项目 实验二-进程调度实验讲义专业班级 姓 名 学 号指导教师 成 绩 日 期一、实验目的通过对进程调度算法的模拟，进一步理解进程的基本概念，加深对进程运行状态和进程调度过程、调度算法的理解。(1)掌握时间...
JAVA操作系统实验进程调度图形化模拟程序
01-10
本文将深入探讨“JAVA操作系统实验进程调度图形化模拟程序”，它基于JAVA 16语言实现，提供了图形用户界面（GUI）来直观展示进程调度的过程。 首先，我们要了解进程调度的基本概念。在多任务操作系统中，多个进程会...
操作系统实验四进程调度.doc
12-23
在操作系统中，进程调度是管理进程执行的关键环节，它决定了哪些进程可以被CPU执行以及何时...总之，这个实验旨在让学生通过实践掌握操作系统中的核心概念——进程调度，以及如何运用不同的调度策略来优化系统的性能。
实验一进程调度 (1).doc
06-21
### 实验一：进程调度 #### 一、实验目的与背景 本次实验旨在通过编写一个简单的进程调度程序来模拟操作系统中的进程调度过程。通过实验，加深对进程调度算法的理解，并掌握如何在实际编程环境中实现这些算法。 #...
状态机的C语言编程（转）
LinSeeker85的博客
01-01 690
收藏于 2012-11-19 迁移自个人的百度空间 ------------------------------ http://blog.csdn.net/ctwei85/article/details/5832092 http://download.csdn.net/detail/wo2008/3417945 auto tools http://sourceforge.net/pro...
## 嵌入式操作系统中任务的相关操作（以uC/ OSiii为例）
qq_46523260的博客
06-17 478
1、任务的创建 void OSTaskCreate (OS_TCB *p_tcb, //任务控制块 CPU_CHAR *p_name, //名称 OS_TASK_PTR p_task, //任务函数 void *p_arg, //传递参数 OS_PRIO prio, //优先级 CPU_STK *p_
OSTaskCreate（）函数分析
热门推荐
silenceee的专栏
11-14 1万+
INT8U  OSTaskCreate (void (*task)(void *pd), void *p_arg, OS_STK *ptos, INT8U prio)；函数返回一个8位的整型数，调用该函数需要四个参数。第一个参数一个指针，也就是用户代码的首地址，在平时使用中我们把自己创建的任务的名字作为这个参数就可以了；第三个参数是指向任务堆栈栈顶的指针，通常我们把创建的任务的堆栈数组的首地址
void (*task) (void *pd)是什么意思
博闻天下-lei的博客
03-15 2575
函数指针可以指向任何类型的带一个参数的函数，void (*task)(void *pd);int func(unsigned char *s);   task = func;   //函数入口地址给函数指针就是可以用task来代替func函数了，定义了一个指向函数的指针task，所指向的函数无返回值，参数为可指向任意类型的指针，入宫写成void*task（void*pd）的形式则是声明了一个tas...
使用C++实现的单向循环链表
weixin_33953384的博客
03-27 111
不多说直接上代码。 注意：其中的Exception类请参考我的博客《使用C++实现的单向链表》 转载于:https://www.cnblogs.com/bobo1223/p/7287651.html
操作系统实验——进程调度（2）
永不止步的博客
06-17 2765
实验任务 设计一个程序,根据不同的调度算法模拟操作系统对进程的调度。 调度算法: 时间片循环法 1、 设计进程控制块PBC表结构，适用循环时间片轮转算法。 2、 PBC结构通常包括以下信息：进程名、进程优先数、轮转时间片、进程的CPU时间，进程状态等。根据调度算法不同，PCB结构可作适当的调整。 3、 建立进程队列。对不同的算法编制不同的入链程序。 程序要求达到的运行效果：在设置好进程...
C++ STL中sort函数
最新发布
weixin_43349440的博客
09-15 269
刷题中经常遇到，用于各种元素排序，可以自定义排序方式，vector、deque适用。详细讲解：https://zhuanlan.zhihu.com/p/36274119。，为避免QuickSort快排的递归调用带来过大的额外负荷，就改用。一旦分段后的数据量小于某个门槛。STL的sort算法，
操作系统实验：进程调度与优先级算法
"进程调度实验，使用高级语言编写和调试进程调度程序，理解进程调度算法，包括最高优先数优先和先来先服务算法。实验涉及进程控制块（PCB），包含进程名、优先数、到达时间、需要运行时间等信息。进程状态包括就绪、...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值