进程调度模拟算法

最新推荐文章于 2023-04-05 18:10:27 发布
最新推荐文章于 2023-04-05 18:10:27 发布
阅读量513 收藏 1
点赞数
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Windwaves613/article/details/72235356
版权

/**进程调度算法

1、先来先服务算法

2、短进程优先算法

**/

 

#include<cstdlib>

#include<iostream>

#include<iomanip>

 

using namespacestd;

 

 

//定义结构体，里面包含的有一个进程相关的信息

struct PCB{  

       char name[10];   

       float arrivetime;   

       float servicetime;   

       float starttime;   

       float finishtime;   

       float zztime;   

       float dqzztime;   

};  

 

PCB a[100]; 

 

/********************输入进程函数********************/ 

void input(PCB*p,int N)   

{

       int i;  

    cout<<endl;

       cout<<"请输入进程的        名字   到达时间   服务时间:  (例如: a 0 100)"<<endl;

        

       for(i=0;i<=N-1;i++)   

       {   

              cout<<"请输入进程"<<i+1<<"的信息";

              cin>>p[i].name;

              cin>>p[i].arrivetime;

              cin>>p[i].servicetime;             

       }   

  

} 

/********************先来先服务算法********************/ 

 

//排序   

void sort_FCFS(PCB*p,int N)   

{   

     for(int i=0;i<=N-1;i++)   

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

            if(p[i].arrivetime<p[j].arrivetime)   

             {   

                 PCB temp;   

                 temp=p[i];   

                 p[i]=p[j];   

                 p[j]=temp;   

             }   

} 

//运行     

void run_FCFS(PCB*p,int N)  

{

       int k;   

    for(k=0;k<=N-1;k++)   

     {   

         if(k==0)   

               {    

                      p[k].starttime=p[k].arrivetime;   

                      p[k].finishtime=p[k].arrivetime+p[k].servicetime;}   

  

         else  

               {   

                      p[k].starttime=p[k-1].finishtime;   

            p[k].finishtime=p[k-1].finishtime+p[k].servicetime;}   

     }   

  

     for(k=0;k<=N-1;k++)   

     {   

               p[k].zztime=p[k].finishtime-p[k].arrivetime;   

               p[k].dqzztime=p[k].zztime/p[k].servicetime;   

        

     }   

}  

 

voidPrint_FCFS(PCB *p,int N)   

{

       int k; 

    cout<<"调用先来先服务算法以后进程运行的顺序是: ";

    cout<<p[0].name;  

       for(k=1;k<N;k++)   

       {

              cout<<"-->";

              cout<<p[k].name;  

       }  

     cout<<endl;

        cout<<"具体进程调度信息:"<<endl;

        cout<<"进程名  到达时间  服务时间  开始时间  结束时间  周转时间  带权周转时间"<<endl;

  

     for(k=0;k<=N-1;k++)   

     {

               cout<<setw(4)<< p[k].name

                      <<setw(8)<< p[k].arrivetime

                      <<setw(10)<< p[k].servicetime

                      <<setw(10)<< p[k].starttime

                      <<setw(10)<< p[k].finishtime

                      <<setw(10)<< p[k].zztime

                      <<setw(10)<<p[k].dqzztime<<endl;

               

     }     

 

}

//先来先服务算法   

void FCFS(PCB*p,int N)   

{   

     sort_FCFS(p,N);   

     run_FCFS(p,N);   

     Print_FCFS(p,N);

        int k;

        float Attime=0;

        float AQttime=0;

        for(k=0;k<=N-1;k++)   

     {  

               Attime+=p[k].zztime; 

               AQttime+=p[k].dqzztime;           

     } 

        Attime=Attime/N;

        AQttime=AQttime/N;

        cout<<"调用先来先服务算法的平均周转时间为: ";

        cout<<Attime<<endl;

        cout<<"调用先来先服务算法的平均带权周转时间为: ";

        cout<<AQttime<<endl;     

}  

 

 

/********************短进程优先算法********************/

 

//排序

void sort_SPF(PCB*p,int N)  

{ 

       /****按照到达时间排序****/

       for(int i=0;i<N-1;i++)  

              for(intj=i+1;j<=N-1;j++)  

                     if(p[i].arrivetime>p[j].arrivetime)  

             {  

                 PCB temp;  

                 temp=p[i];  

                 p[i]=p[j];  

                 p[j]=temp;  

             }

       for(int m=0;m<N-1;m++)      

       {

              if(m==0)  

                     p[m].finishtime=p[m].arrivetime+p[m].servicetime;  

         else 

           p[m].finishtime=p[m-1].finishtime+p[m].servicetime;

               

               /****查找当前进程执行过程中进入系统的进程****/

               int i=0;

         for(int n=m+1;n<=N-1;n++)  

               {

                      if(p[n].arrivetime<=p[m].finishtime)             

                             i++;  

               }  

               /****选择最短的为接下来执行的****/

               float min=p[m+1].servicetime;  

               int next=m+1;//m+1=n  

       

               for(int k=m+2;k<=m+i;k++)         

               {  

        

                      if(p[k].servicetime<min)  

                      {

                             min=p[k].servicetime;             

                             next=k;}                            

               }  

          

               PCB temp;              

               temp=p[m+1];             

               p[m+1]=p[next];             

               p[next]=temp;          

       }   

}  

 

//运行

void run_SPF(PCB*p,int N)

{

       int k;

    for(k=0;k<=N-1;k++)

     {

              if(k==0)

              {

                     p[k].starttime=p[k].arrivetime;

                     p[k].finishtime=p[k].arrivetime+p[k].servicetime;

              }

              else

              {

                     p[k].starttime=p[k-1].finishtime;

            p[k].finishtime=p[k-1].finishtime+p[k].servicetime;

              }

       }

       for(k=0;k<=N-1;k++)   

       {   

 

              p[k].zztime=p[k].finishtime-p[k].arrivetime;   

              p[k].dqzztime=p[k].zztime/p[k].servicetime;   

       }   

}

 

//显示结果

void Print_SPF(PCB*p,int N)

{

     int k;

        cout<<"调用最短进程优先调度算法以后进程的调度顺序为: ";

        cout<<p[0].name;  

        for(k=1;k<N;k++)

        {

               cout<<"-->";

               cout<<p[k].name; 

        }

        cout<<endl;

        cout<<"具体进程调度信息:"<<endl;

        cout<<"进程名  到达时间  运行时间  开始时间  完成时间"<<endl;

 

     for(k=0;k<=N-1;k++)

     {                

               cout<<setw(4)<< p[k].name

                      <<setw(8)<< p[k].arrivetime

                      <<setw(10)<< p[k].servicetime

                      <<setw(10)<< p[k].starttime

                      <<setw(10)<< p[k].finishtime

                      <<endl;

      } 

}

 

//最短进程优先算法

void SPF(PCB*p,int N)

{

       sort_SPF(p,N);

       run_SPF(p,N);

       Print_SPF(p,N);

 

       int k;

       float Attime=0;

       float AQttime=0;

       for(k=0;k<=N-1;k++)   

       {  

              Attime+=p[k].zztime; 

              AQttime+=p[k].dqzztime;      

       } 

       Attime=Attime/N;

       AQttime=AQttime/N;

       cout<<"调用最短进程优先算法的平均周转时间为: ";

       cout<<Attime<<endl;

       cout<<"调用最短进程优先算法的平均带权周转时间为: ";

       cout<<AQttime<<endl;

          

}

 

/********************主函数选择算法********************/

int main(void)

{

       for(;;)

       {

              int N;  

              cout<<endl;                                      

              cout<<"输入进程数目:"<<endl;

              cin>>N;                           

              input(a,N);   

       char chose;

       cout<<"请选择进程调度方法"<<endl;

       cout<<"输入 f 或者 F 执行先来先服务算法："<<endl;

       cout<<"输入 s 或者 S 执行先来先服务算法："<<endl;

       cin>>chose;

       switch(chose)

       {

       case 'f':

       case 'F':

              cout<<endl;                                      

              cout<<"<<----------!!!@@@先来先服务调度算法@@@!!!---------->>"<<endl;                          

              cout<<endl;                                         

              FCFS(a,N);

              break;

 

                          

       case 's':                     

       case 'S':                  

              cout<<endl;                         

              cout<<"<<----------!!!@@@最短进程优先调度算法@@@!!!---------->>"<<endl;                           

              cout<<endl;                                                                    

              SPF(a,N);

              break;

        

       }

       }

}

 

Windwaves613
关注
进程调度算法模拟
pp_517318的博客
11-14 5786
1、绪论 1.1 了解进程调度算法的特点 1.2熟悉进程结构体数组。 1.3 掌握进程调度算法：时间片轮转法（RR）、短进程优先法（SJF） 2、实验内容 2.1 设计C语言程序，模拟实现进程调度算法 2.1.1 时间片轮转法（RR） 将所有的就绪进程按先来先服务的原则排成一个队列，每次调度时，把处理机分配给队首进程，并令其执行一个时间片。 2.1.2 短进程优先法（SJF） 以进入系统的作业所要求的CPU运行时间的长短为挑选依据，优先选取预计所需服务时间最短的作业进行调度，可以分别用于.
操作系统进程调度模拟算法
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） 一直到就绪队列为空，程序执行结束。
进程调度算法的模拟实现
06-17
操作系统进程调度课设，有先来先服务、 短作业优先 、最短剩余时间优先 、时间片轮换、 高优先权调度五种算法
进程调度模拟算法源码+项目说明.zip
03-17
进程调度模拟算法源码+项目说明.zip进程调度模拟算法源码+项目说明.zip进程调度模拟算法源码+项目说明.zip进程调度模拟算法源码+项目说明.zip进程调度模拟算法源码+项目说明.zip进程调度模拟算法源码+项目说明.zip...
进程调度算法模拟程序设计C++.docx
05-29
进程调度算法模拟程序设计 C++ 在操作系统中，进程调度算法是核心组件之一，负责分配系统资源和管理进程的执行顺序。下面我们将对进程调度算法的模拟程序设计进行详细的分析和解释。 进程调度算法 进程调度算法...
操作系统-进程调度模拟算法(附源码).doc
最新发布
05-07
### 操作系统中的进程调度模拟算法 #### 实验目的 本次实验的核心目标是通过编写模拟进程调度程序来加深对操作系统中处理机管理的理解。重点在于掌握进程控制块（Process Control Block, PCB）的概念及其结构，同时...
实验一：进程调度模拟算法.rar
08-24
本实验“实验一：进程调度模拟算法”旨在深入理解和改进进程调度算法，以便提高系统的整体性能和响应时间。我们将探讨相关知识点，包括进程调度的基本概念、常见调度策略以及如何进行模拟和优化。 首先，我们要理解...
操作系统进程调度模拟（共三种算法）完整代码
12-22
操作系统课程设计作品！模拟进程调度共三种算法(先来先服务、动态优先权、轮转法)，完整代码，详细注释，VC环境运行成功！ 使用先来先服务、动态优先权、轮转法模拟进程调度。 对动态优先权、轮转法简化假设为： 1、进程为计算型的（无I/O） 2、进程状态：ready、running、finish 3、进程需要的CPU时间以时间片为单位确定。 对动态优先权算法，当前运行进程用完时间片后，其优先权减去一个常数。
进程调度模拟(C语言实现)
05-29
NULL 博文链接：https://touch-2011.iteye.com/blog/1047163
进程调度算法模拟程序设计
07-01
进程调度算法模拟程序设计,利用优先级进行调度， （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）分析程序运行的结果，谈一下自己的认识。
计算机操作系统进程调度算法模拟
06-11
进程调度算法模拟。通过对进程调度算法的模拟，进一步理解进程的基本概念，加深对进程运行状态和进程调度过程、调度算法的理解。 （1） 用C、C++、Java语言编程实现对5个进程采用动态优先权调度算法进行调度的过程。数据如下： 5个进程的到达时刻和服务时间见下表，忽略I/O以及其它开销时间，使用动态优先权算法进行调度，优先权初始值为100，请输出各个进程的完成时刻、周转时间、带权周转时间。 进程 到达时刻 服务时间 A 0 3 B 2 6 C 4 4 D 6 5 E 8 2 （2）每个用来标识进程的进程控制块PCB可用结构来描述，包括以下字段（用不到的字段可以不定义）。  进程标识数ID。  进程优先数PRIORITY，并规定优先数越大的进程，其优先权越高。  进程已占用CPU时间CPUTIME。  进程还需占用的CPU时间ALLTIME。当进程运行完毕时，ALLTIME变为0。  进程的阻塞时间STARTBLOCK，表示当进程再运行STARTBLOCK个时间片后，进程将进入阻塞状态。  进程被阻塞的时间BLOCKTIME，表示已阻塞的进程再等待BLOCKTIME个时间片后，将转换成就绪状态。  进程状态STATE。  队列指针NEXT，用来将PCB排成队列。 （3）优先数改变的原则：  进程在就绪队列中呆一个时间片，优先数增加1。  进程每运行一个时间片，优先数减3。 （4）为了清楚地观察每个进程的调度过程，程序应将每个时间片内的进程的情况显示出来，包括正在运行的进程，处于就绪队列中的进程和处于阻塞队列中的进程。 （5）分析程序运行的结果，谈一下自己的认识。
《操作系统》进程调度算法模拟
05-28
用C、C++、Java语言编程实现对5个进程采用动态优先权调度算法进行调度的过程。
进程调度算法思想以及模拟算法
weixin_45859411的博客
12-06 687
先来先服务算法（FCFS） ​ 用于进程调度时，每次调度从就绪队列中选择一个最先进入该队列的进程，为之分配处理机，投入运行。属于非抢占式算法。 进程名 到达时间（arrive） 服务时间(service) 开始时间(start) 完成时间(finsh) 周转时间(time) A 0 3 0 3 3 B 2 6 3 9 7 C 4 4 9 13 9 D 6 5 13 18 12 E 8 2 18 20 12 执行顺序 A B C D E 平均周转时间8.6 算法
进程调度算法的模拟
qq_69749315的博客
04-05 433
然后用“gcc -o schedule schedule.c”得到可执行文件。用“./schedule”执行schedule得到如下。加深对进程概念的理解，明确进程和程序的区别。先写一个名为“schedule.c”的文件。
进程调度模拟算法实现
10-02
进程调度模拟算法的实现有多种方法，其中包括以下几种常见的算法： 1. 先来先服务调度算法（First-Come, First-Served Scheduling Algorithm, FCFS）：按照进程到达的先后顺序进行调度，即先到达的进程先执行。 2. 短作业优先调度算法（Shortest Job First Scheduling Algorithm, SJF）：根据进程的执行时间长度来确定优先级，执行时间越短的进程优先级越高。 3. 时间片轮转调度算法（Round Robin Scheduling Algorithm, RR）：将所有就绪进程按顺序排列在一个就绪队列中，每个进程被分配一个时间片，当时间片用完后，进程被移到队列的末尾，等待下一轮调度。 4. 多级反馈队列调度算法（Multilevel Feedback Queue Scheduling Algorithm）：将就绪队列划分为多个子队列，根据进程的特性和类型将进程分配到相应的队列中，不同队列采用不同的调度算法，如前台队列采用时间片轮转算法，后台队列采用高优先权或短作业优先算法。 以上是一些常见的进程调度模拟算法实现方法，根据实际需求和系统特点选择适合的算法进行模拟实现。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值