操作系统进程调度算法实现

最新推荐文章于 2023-11-14 00:16:14 发布
最新推荐文章于 2023-11-14 00:16:14 发布
阅读量429 收藏 1
点赞数 1
文章标签： 操作系统 进程调度
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/rj2017211811/article/details/89484126
版权

bug好多，待完善

#include<unistd.h>
#include<stdio.h>
#include<stdlib.h>
//enum STATE{Ready,Running,Blocked};

#define MAX_SIZE 100
typedef struct process_pcb
{

    //进程ID
    int ID;//process ID

    int priority;
    int arrive_time;
    int service_time;
    int start_time;
    int end_time;
    int all_time;
    int cpu_time;
    int state;
    //周转时间=结束时间-到达时间
    int circulation_time;
    //带权周转时间=周转时间/服务时间
    int circulateWeight_time;
    int executeSequence;
    int remaining_time;





} PCB;
typedef struct
{

    PCB data[MAX_SIZE];
    int font,rear;

} sqQueue;
sqQueue*  initQueue()
{
    sqQueue *q=(sqQueue*)malloc(sizeof(sqQueue));
    if(q!=NULL)
    {
        q->font=0;
        q->rear=0;
        //  printf("%d %d",q->font,q->rear);
        //  printf("queue initalized successfully.\n");


    }
    return q;


}
int isEmpty(sqQueue *q)
{
    if(q->rear==q->font)
    {
        return 1;
    }
    return 0;

}
int enQueue(sqQueue *q,PCB  data)
{
    if((q->rear+1)%MAX_SIZE==q->font)
    {

        return 0;
    }
    else
    {
        q->rear=(q->rear+1)%MAX_SIZE;
        q->data[q->rear]=data;
        return 1;

    }


}

int deQueue(sqQueue *q,PCB *data)
{
    if(q->rear==q->font)
    {
        return 0;

    }
    else
    {
        q->font=(q->font+1)%MAX_SIZE;
        *data=q->data[q->font];
        return 1;
    }


}
//按照服务时间最小排序
sqQueue* selectSort(PCB pcb[],int n)
{
    sqQueue *readyQueue=initQueue();
    int i,j;
    int t;
    PCB t2;
    for(i=0; i<n; i++)
    {
        for(j=i+1; j<n; j++)
        {
            if(pcb[i].arrive_time>pcb[j].arrive_time)
            {
                t=pcb[i].executeSequence;
                pcb[i].executeSequence=pcb[j].executeSequence;
                pcb[j].executeSequence=t;
                t2=pcb[i];
                pcb[i]=pcb[j];
                pcb[j]=t2;

            }
        }
        enQueue(readyQueue,pcb[i]);
        // printf("%d ",pcb[i].arrive_time);
    }
    return readyQueue;
}

//按照优先级最小排序
sqQueue* selectSort2(PCB pcb[],int n)
{
    sqQueue *readyQueue=initQueue();
    int i,j;
    int t;
    PCB t2;
    for(i=0; i<n; i++)
    {
        for(j=i+1; j<n; j++)
        {
            if(pcb[i].priority>pcb[j].priority)
            {
                t=pcb[i].executeSequence;
                pcb[i].executeSequence=pcb[j].executeSequence;
                pcb[j].executeSequence=t;
                t2=pcb[i];
                pcb[i]=pcb[j];
                pcb[j]=t2;

            }
        }
        enQueue(readyQueue,pcb[i]);
        // printf("%d ",pcb[i].arrive_time);
    }
    return readyQueue;
}
void printProcess(PCB pcb1);
//先来先服务
void FCFS(PCB pcb[],int n,sqQueue*readyQueue)
{
    int time=0;
    int i=0;
    printf("\n");
    /* for(i=0; i<n; i++)
     {
         pcb[i].start_time=time;
         printf("process %d  start,start_time:%d,",pcb[i].ID,pcb[i].start_time);
         time+=pcb[i].service_time;
         pcb[i].end_time=time;
         pcb[i].executeSequence=i;
         printf("process %d end,end_time:%d\n",pcb[i].ID,pcb[i].end_time);
     }*/

    while(readyQueue->rear!=readyQueue->font)
    {
        PCB pcb1;

        deQueue(readyQueue,&pcb1);
        pcb1.start_time=time;
        time+=pcb1.service_time;


        pcb1.end_time=time;
        pcb1.circulation_time=pcb1.end_time-pcb1.arrive_time;
        pcb1.circulateWeight_time=pcb1.circulation_time/pcb1.service_time;
        pcb1.remaining_time=pcb1.remaining_time-pcb1.service_time;
        //enQueue(readyQueue,pcb[i]);


        i++;
        printProcess(pcb1);


    }
    // printProcess(pcb,n);
}
void printProcess(PCB pcb1)
{

    printf("ID arrive_time service_time start_time end_time circulation_time circulateweight_time remaining_time  priority\n");

    printf("%d %6d %10d %10d %10d %10d %14d %20d %16d\n",pcb1.ID,pcb1.arrive_time,pcb1.service_time,pcb1.start_time,pcb1.end_time,pcb1.circulation_time,pcb1.circulateWeight_time,pcb1.remaining_time,pcb1.priority);

}
//短作业优先,非抢占
void SJF(PCB pcb[],int num,sqQueue *readyQueue)
{
    //readyQueue=selectSort(pcb,num);
    int time=0;
    int i=0;
    printf("\n");
    //到达队列存储当前已经到达的进程信息
    sqQueue*arriveQueue;
    int j=0;
    while(readyQueue->rear!=readyQueue->font)
    {
        //看当前是否有进程已经到达
        for(i=j; i<num; i++)
        {

            if(pcb[i].arrive_time>time)
            {
                enQueue(arriveQueue,pcb[i]);
            }
            else
            {
                j=i;
                break;
            }
        }
        //对当前已经到达的进程进行按照服务时间由低到高排序


        //执行最短作业的进程,把该进程从到达队列里出列

    }
    // printProcess(pcb,num);

}
//最短剩余时间优先，抢占
void SRT(PCB pcb[],int num,sqQueue *readyQueue)
{

    while(readyQueue->rear!=readyQueue->font)
    {
        //查看当前是否有进程到达

        //如果有进程到达，查询当前时间是否

    }

}
//时间片轮转算法
void RR(sqQueue* readyQueue,PCB pcb[],int num,int timeLength)
{
    int time=0;
    int i=0;
    //初始化就绪队列
    //sqQueue *readyQueue=initQueue();

    //第一个进程0时刻到达，加入就绪队列
    /* i=0;
     enQueue(readyQueue,pcb[i]);
     i++;*/

    //初始化完成队列
    sqQueue *finishQueue=initQueue();
    int k=0;
    while(1)
    {
        //查看当前时间片是否有进程到达
        /* int j;
         for(j=i; j<num; j++)
         {

             if(pcb[j].arrive_time<=time)
             {
                 enQueue(readyQueue,pcb[j]);
                 printf("process %d has put into readyQueue int time %d\n",pcb[j].ID,pcb[i].arrive_time);
             }
             else
             {sqQueue* readyQueue,PCB pcb[],int num
                 i=j;

                 break;
             }
         }*/
        //到达队列执行一个时间片,如果一个进程为到一个时间片，则该进程加到队列末尾
        PCB pcb1;
        time+=timeLength;
        deQueue(readyQueue,&pcb1);
        pcb1.start_time=time-timeLength;
        pcb1.end_time=time;
        pcb1.circulation_time=pcb1.end_time-pcb1.arrive_time;
        pcb1.circulateWeight_time=pcb1.circulation_time/timeLength;
        printf("pcb1.remaining_time:%d timeLength:%d\n",pcb1.remaining_time,timeLength);

        if(pcb1.remaining_time>timeLength)
        {

            pcb1.remaining_time=pcb1.remaining_time-timeLength;
            printProcess(pcb1);
            enQueue(readyQueue,pcb1);
        }
        else
        {
            pcb1.remaining_time=0;
            printProcess(pcb1);
            printf("processs %d has finished\n",pcb1.ID);
            enQueue(finishQueue,pcb1);
            k++;


        }
        if(k==num)
        {
            printf("all processes has finished\n");

            break;
        }

    }
}
//动态优先级算法
void dynamicPriority(sqQueue* readyQueue,PCB pcb[],int num)
{
    //规定程序占用cpu时间大于1,优先级减小0.5
    //程序等待时间大于1，优先级增加1
    //程序等待时间=当前cpu时间-程序到达时间
    int nums=num;


    readyQueue=selectSort2(pcb,num);

    int time=0;
    int i=0;
    int k;
    int finished=0;
    printf("\n");
    while(readyQueue->rear!=readyQueue->font)
    {

        PCB pcb1;

        deQueue(readyQueue,&pcb1);
        if(pcb1.remaining_time>1)
        {
            pcb1.priority-=0.5;
            pcb1.remaining_time=pcb1.remaining_time-1;
            pcb1.start_time=time;
            time+=1;
            pcb1.end_time=time;
            pcb1.circulation_time=pcb1.end_time-pcb1.arrive_time;
            pcb1.circulateWeight_time=pcb1.circulation_time/1;
            pcb1.remaining_time=pcb1.remaining_time-1;
            pcb1.arrive_time=time;

            printProcess(pcb1);
            //直接更新就绪队列
            printf("1 ");

            for(k=0; k<num; k++)
            {

                if(pcb[k].ID==pcb1.ID)
                {
                    pcb[k]=pcb1;


                }

            }
            printf("2 ");

            readyQueue=selectSort2(pcb,num);
            printf("3 ");




        }
        else
        {
            pcb1.start_time=time;
            time+=pcb1.service_time;
            pcb1.end_time=time;
            pcb1.circulation_time=pcb1.end_time-pcb1.arrive_time;
            pcb1.circulateWeight_time=pcb1.circulation_time/pcb1.service_time;
            pcb1.remaining_time=pcb1.remaining_time-pcb1.service_time;
            if(pcb1.remaining_time==0)
            {

                pcb1.remaining_time=0;
            }
            printProcess(pcb1);
            printf("process %d has finished\n",pcb1.ID);
            finished++;

            if(finished==nums)
            {
                break;

            }


            //删除数组中的元素

            PCB pcb2[num-1];
            int j=0;

            for(k=0; k<num; k++)
            {

                if(pcb[k].ID!=pcb1.ID)
                {
                    pcb2[j]=pcb[k];
                    j++;

                }

            }
            num-=1;
            pcb=pcb2;



            //更新就绪队列
             readyQueue=selectSort2(pcb,num);
             for(k=0; k<num; k++)
            {
                printProcess(pcb2[k]);


            }


        }

        //等待时间过程的进程优先级增加
        for(k=0; k<num; k++)
        {


            int wait_time=time-pcb[k].arrive_time;
            pcb[k].priority+=wait_time;


        }
        printf("remaining process num:%d\n",num);





    }


}
//静态优先级算法
void staticPriority(sqQueue* readyQueue,PCB pcb[],int num)
{
    readyQueue=selectSort2(pcb,num);

    int time=0;
    int i=0;
    printf("\n");
    /* for(i=0; i<n; i++)
     {
         pcb[i].start_time=time;
         printf("process %d  start,start_time:%d,",pcb[i].ID,pcb[i].start_time);
         time+=pcb[i].service_time;
         pcb[i].end_time=time;
         pcb[i].executeSequence=i;
         printf("process %d end,end_time:%d\n",pcb[i].ID,pcb[i].end_time);
     }*/

    while(readyQueue->rear!=readyQueue->font)
    {

        PCB pcb1;

        deQueue(readyQueue,&pcb1);
        pcb1.start_time=time;
        time+=pcb1.service_time;


        pcb1.end_time=time;
        pcb1.circulation_time=pcb1.end_time-pcb1.arrive_time;
        pcb1.circulateWeight_time=pcb1.circulation_time/pcb1.service_time;
        pcb1.remaining_time=pcb1.remaining_time-pcb1.service_time;
        //enQueue(readyQueue,pcb[i]);


        i++;
        printProcess(pcb1);


    }


}

int main()
{
    sqQueue *readyQueue=initQueue();
    int num;
    printf("\nPlease input the num of process.\n");
    scanf("%d",&num);
    int i=0;
    PCB pcb[num];
    printf("Please input information for ready.\n");
    for(i=0; i<num; i++)
    {
        printf("Please input the %d process priority,arrive_time,service_time\n",i);
        scanf("%d %d %d",&pcb[i].priority,&pcb[i].arrive_time,
              &pcb[i].service_time);
        pcb[i].ID=i;
        pcb[i].state=0;
        pcb[i].remaining_time=pcb[i].service_time;
        pcb[i].cpu_time=0;
        pcb[i].start_time=0;
        pcb[i].end_time=0;
        pcb[i].circulation_time=0;
        pcb[i].circulateWeight_time=0;


        printf("%d\n",enQueue(readyQueue,pcb[i]));

    }

    //FCFS(pcb,num,readyQueue);

    //时间片轮转算法
    /*int timeLength;
    printf("Please input the length of time:\n");
    scanf("%d",&timeLength);
    RR(readyQueue,pcb,num,timeLength);*/

    dynamicPriority(readyQueue,pcb,num);
    // staticPriority(readyQueue,pcb,num);


    /* for(i=0;i<num;i++)
     {

         printf("%d %d %d\n",pcb[i].priority,pcb[i].arrive_time,pcb[i].service_time);

     }*/
    /*readyQueue= selectSort(pcb,num);
    PCB data;
    int result=0;
    while(( result=deQueue(readyQueue,&data))>0)
    {
        printf("process %d deQueue\n",data.ID);

    }

    printf("process has put into queue");*/



    /* FCFS(pcb,num);

    SJF(pcb,num);*/

    return 0;
}
I like study.
关注
  • 1
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
C#版操作系统实验—CPU调度
giver
12-08 895
using System; using System.Collections.Generic; using System.ComponentModel; using System.Data; using System.Drawing; using System.Linq; using System.Text; using System.Threading.Tasks; using
进程调度C#源代码优先级加轮转
06-19
用C#实现进程调度，才用优先级加轮转算法，时间片为5
操作系统进程调度C++代码实现
05-25
目的: 在进程控制、请求分页存储器管理、设备管理基础上 实现按先来先服务 FCFS 、短作业优先 SJF 以及时间片 轮转算法调度进程的模拟过程 。 内容 1.在第 1 3 部分基础上扩展； 2.支持 FCFS 、短 作业优先以及时间片调度算法。 3.能够较方便地查看调度过程及平均周转时间、平均带权周转时 间。 4.支持优先权调度算法与其它算法相结合的调度模式。 5.调度时应适当输出调度过程中各进程状态队列的变化情况以及进程的已执行时 间、还需服务时间（针对时间片轮转算法）。 6.完成银行家算法的实现。
基于C# winform的操作系统课程设计：SPOOLING假脱机输入输出技术模拟
KI的博客
12-09 6897
基于C# winform的操作系统课程设计：SPOOLING假脱机输入输出技术模拟
操作系统4种进程调度算法（c语言）
最新发布
weixin_74337975的博客
11-14 3252
抢占性的 HPF 允许正在执行的进程被更高优先级的进程中断，以便立即执行更高优先级的任务。需要注意的是，SJF 算法的一个问题是它对于长服务时间的进程可能会导致其他进程长时间等待，可能会出现饥饿（Starvation）的情况。这是一种非抢占式的调度算法，即一旦进程开始执行，就一直执行到完成，除非有更短的作业进入就绪队列。在这种算法中，进程按照它们到达就绪队列的顺序依次执行，即先到达的进程先执行，后到达的进程排队等待。如果新进程的服务时间比当前正在执行的进程更短，那么系统会中断当前进程，转而执行新的进程。
操作系统模拟进程调度算法C#Winfrom实现
12-25
总的来说，这个项目不仅提供了对操作系统进程调度理论的理解，还锻炼了C#编程和GUI设计的能力。通过实际操作，你可以更深入地理解各种调度算法的工作原理及其优缺点，这对于学习操作系统和软件开发都是非常有益的。
操作系统磁盘调度算法实验报告
05-07
操作系统磁盘调度算法实验报告 本实验报告的主要目的是设计一个磁盘调度模拟系统，旨在使磁盘调度算法更加形象化、易于理解，使磁盘调度的特点更简单明了。通过本实验，学生可以加深对先来先服务算法、最短寻道时间...
操作系统进程调度算法
01-13
本文将深入探讨四种常见的进程调度算法：先来先服务（FCFS）、短进程优先（SPF）、高响应比优先（HRN）以及时间片轮转（RR），并结合提供的文件名，我们可以推测这可能是一个关于这些算法实现的编程项目。...
进程调度算法的实现计算机操作系统课程设计.docx
08-26
进程调度算法的实现计算机操作系统课程设计 进程调度算法是计算机操作系统中的一种关键技术，它负责管理和调度系统中的进程，以提高系统的效率和性能。本文将详细介绍进程调度算法的实现计算机操作系统课程设计的...
操作系统——调度算法
西岸贤
08-08 1万+
本文的主要内容是调度算法的介绍，包括先来先服务(FCFS)、最短时间优先(SJF)、最高响应比优先(HRRN)、时间片轮转(RR)、优先级调度和多级反馈队列这六种方法，这些调度算法会从其算法思想、算法规则、该方法用于作业调度还是进程调度、进程调度的方式(抢占式和非抢占式)、优缺点以及是否会导致饥饿这几个方面展开介绍，同时在介绍每种调度算法时还会举例子辅助理解。...
操作系统实验之进程调度 （C#编写，GUI界面）
09-25
用C#编写的进程调度程序，包括优先权调度算法，时间片轮转法。能够显示每一步进程的变化情况。
操作系统课程设计之进程调度源代码（六种调度算法 c++）
01-16
编写程序模拟进程调度过程，能够按照时间片轮转，短进程优先法，可抢占式和不可抢占式优先级法，以及先来先服务和高响应比优先法处理输入的数据，运行结果包含界面。
操作系统实验-单处理器系统的时间片轮转进程调度-python实现
12-25
大学操作系统课程 综合实验 单处理器系统的时间片轮转进程调度 算法，使用python实现。带注释。
【操作系统】操作系统的进程调度算法
互联网小阿祥
12-08 657
操作系统的进程调度算法
常用的进程调度算法
越陌度阡
12-14 6179
进程调度是由操作系统的进程调度程序按照某种策略和算法从就绪态进程中为当前空闲的CPU选择要运⾏的新进程，常用的进程调度算法有以下几种： 1. 先来先服务调度算法 从就绪队列的队⾸选择最先到达的进程，为该进程分配CPU。下面通过一个例子来说明先来先服务算法。 已知：就续队列中有3个进程， 分别为P1、P2、P3，进入系统的时间分别为0、1、2，服务时间分别为24、3、3，求3个进程的系统......
实验六：《操作系统》之进程调度算法的模拟实现
qq_41713240的博客
06-28 1万+
Part6. 进程调度算法的模拟实现 往期回顾： Part0. 实验环境 Part1-1.熟悉UKylin环境 Part1-2.熟悉UKylin环境 Part2.进程控制 Part3.进程通信 Part4.管道通信 Part5.避免死锁——银行家算法的实现 一、实验目的 1.理解和掌握课堂上讲的进程调度算法，并编程模拟实现调度过程。 2.研究进程调度算法的实现方法，并对算法性能参数进行对比。 二、实验要求 编程模拟实现传统的进程调度算法：FCFS调度算法、SPF调度算法、RR调度算法、优先级调度等算法。
操作系统中的进程调度策略有哪几种
热门推荐
张花生的博客
09-22 4万+
先来先服务调度算法：先来先服务(FCFS)调度算法是一种最简单的调度算法，该算法既可用于作业调度，也可用于进程调度。当在作业调度中采用该算法时，每次调度都是从后备作业队列中选择一个或多个最先进入该队列的作业，将它们调入内存，为它们分配资源、创建进程，然后放入就绪队列。在进程调度中采用FCFS算法时，则每次调度是从就绪队列中选择一个最先进入该队列的进程，为之分配处理机，使之投入运行。该进程一直运行到...
操作系统是如何调度进程的呢
Cris
03-28 3518
(一) 进程调度的任务：（1）保存处理机的现场信息，如程序计数器、多个通用寄存器中的内容（2）按照某种算法选取进程，将其状态改为运行状态（3）把处理器分配给进程，由分派程序把处理器分配给该进程，将进程控制块内有关处理器现场的信息装入处理器相应的各个寄存器中，把处理器的控制权交给该进程，让他从上次断点处恢复运行(二) 进程调度机制：a)       排队器将所有就绪的进程按照一定的策略排成一个或多个...
【操作系统】完成读者-写者问题的伪代码。要求按照先来先服务的原则进行读者写者的调度。
qq_41438541的博客
03-31 2444
操作系统进程调度算法课程设计-学位论文.doc
06-30
"操作系统进程调度算法课程设计-学位论文.doc" 这篇学位论文的主题聚焦于操作系统中的进程调度算法，主要探讨了两种常见的调度策略：最高优先数优先（HPF）算法和先来先服务（FCFS）算法。在操作系统中，由于处理机...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值