linux操作系统实验-进程调度实验

已于 2022-12-17 21:20:39 修改
阅读量1.7k 收藏 23
点赞数
文章标签： linux c++
于 2022-11-29 20:36:58 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_41714523/article/details/128104473
版权

一、实验目的

 

本实验的目的是通过作业或进程调度算法模拟设计，进一步加深对作业或进程调度算法的理解，通过计算平均周转时间和带权平均周转时间，进一步加深对算法的评价方法的理解。

二、实验预备内容

  1. 掌握作业或进程调度算法

  2. 平均周转时间和带权平均周转时间计算。

三、实验内容

设定一组作业或进程，给定相关参数，对这组进程或作业按照调度算法实时调度，输出调度次序，并计算平均周转时间和带权平均周转时间，使用的调度算法有：

  1. 先来先服务调度算法；
  2. 优先级调度算法；
  3. 短作业（或进程）优先调度算法；
  4. 响应比高优先调度算法。

四、分析设计

1.提示：使用的主要数据结构

  1. 定义一个结构体，结构体的主要成员有序号、作业（进程）号或名称、提交时间、运行时间、优先数、进入输入井时间、开始运行时间、尚需运行时间、运行结束时间、周转时间、带权周转时间和运行次序等。
  2. 利用定义的结构体，定义一个结构体数组，用来记录系统中的作业或进程。
    主控程序算法、数据输入算法、数据输出算法、先来先服务调度算法、响应比高优先调度算法、优先级调度算法和短作业（或进程）优先调度算法描述分别如图10.2至图10.8所示。

2.文件的结构

3.基础部分

  • 结构体：
struct process {

    int serial;//序号

    char name;//进程名

    int num;//进程号

    float submit;//提交时间

    float runtime;//运行时间

    int priority;//优先级

    float starttime;//开始运行时间

    float endtime;//最终结束时间

    float Turnaround;//周转时间，endtime-submit

    float Wturnaround;//带权周转时间，Turnaround/runtime

    int sort;//运行状态，运行次序，非0即为已经运行

};
  • 模拟进程调度数据初始化及打印
void initproc(struct process p[]){

    int i;

    char flag='A';

    float time;

    int priority;

        for( i=1;i<=4;i++){

                p[i].serial=i;

                p[i].name=flag;



                flag++;

                p[i].num=i;

                printf("the time of %dth process's submit is :\n",i);

                scanf("%f",&time);

                p[i].submit=time;

                printf("the time of %dth process's runtime is :\n",i);

                scanf("%f",&time);

                p[i].runtime=time;

                printf("the priority of %dth process is :\n",i);

                scanf("%d",&priority);

                p[i].priority=priority;

                p[i].sort=0;

                p[i].starttime=0;

                p[i].endtime=0;

                p[i].Turnaround=0;

                p[i].Wturnaround=0;



    }

}

void Print(struct process p[]){

    printf("%s\t%s\t%s\t%s\t%s\t%s %s %s\t%s\t%s\t%s\n","serial","name","num","submit","runtime","priority","starttime","endtime","Turnaround","Wturnaround","sort");

    int i;

    for(i=1;i<=4;i++){

         printf("%d\t%c\t%d\t%.2f\t%.2f\t%d\t %.2f\t    %.2f\t%.2f\t\t%.2f\t\t%d\n",p[i].serial,p[i].name,p[i].num,p[i].submit,p[i].runtime,p[i].priority,p[i].starttime,p[i].endtime,p[i].Turnaround,p[i].Wturnaround,p[i].sort);



    }

}

  • 主函数
int main(void){



   char i,j;

   struct process p[5];

   printf("select dispatch of process: 1.(FCFS)2.(PS) 3.(JSF) 4.(HRRN) 0.(exit)\n");

    while(i=getchar()){

            if(i=='0'){

                printf("exit");

                exit(0);

            }

        switch(i){

        case '1':

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

            initproc(p);

            Fcfsprocess(p);

            Print(p);

            break;

        case '2':

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

            initproc(p);

            Psprocess(p);

            Print(p);

            break;

        case '3':

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

            initproc(p);

            Sjfprocess(p);

            Print(p);

            break;

        case '4':

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

             initproc(p);

             Hrrnprocess(p);

             Print(p);

             break;

        default:

            printf("select dispatch of process: 1.(FCFS)2.(PS) 3.(JSF) 4.(HRRN) 0.(exit)\n");

            break;



        }

    }

    return 0;

}

4.调度算法（主要部分）

1.先来先服务(FCFS) void Fcfsprocess(struct process p[])

void Fcfsprocess(struct process p[]){

    int i=0,j=0;

    int s=1;

    float earlytime=0;

    float starttime=0;

    float endtime=0;

    for(i=1;i<5;i++ )

        {

            earlytime=p[i].submit;

            s=i;

            for(j=1;j<5;j++)

            {

                if(p[j].sort!=0){ continue;}//运行过的进程不参与比较

                if(earlytime>p[j].submit)

                {

                        earlytime=p[j].submit;

                        s=j;//优先级s=提交时间最早的p的序号;

                }

            }

            if(i==1){//比较完成后，开始运行

                starttime=earlytime;

            }

           p[s].sort=i;

           p[s].starttime=starttime;

           endtime=starttime+p[s].runtime;

           p[s].endtime=endtime;

           p[s].Turnaround=endtime-p[s].submit;

           p[s].Wturnaround=p[s].Turnaround/p[s].runtime;

           starttime=endtime;

        }

}

思想：就是通过比较进程提交时间，确定每个进程的优先级，之后进行相应的运算

即if(earlytime>p[j].submit) {

    earlytime=p[j].submit;

    s=j；

 }

p[s].sort=i;

p[s].starttime=starttime;……//确定开始运行下一进程的进程编号，将进程结构体的数据更新

2.优先调度 void Psprocess(struct process p[]);

void Psprocess(struct process p[]){



    int i=0,j=0;

    int s=1;//当前应该进行的作业号

    float pmin=0;//优先最小的

    float starttime=0;

    float endtime=0;

    for(i=1;i<5;i++ )

        {

                if(i==1)//初始化提交时间最早的调度为第一个调度

                {

                    starttime=p[i].submit;

                }

                else

                {

                    for(j=2;j<5;j++)//找出没有运行的调度

                    {

                        if((p[j].sort==0) &&(p[j].submit<=starttime))//未运行的且提交时间已经到的进程

                        {

                            pmin=p[i].priority;

                            s=j;

                            break;//跳出循环

                        }

                    }

                }//上面一段作用：找出未运行的作业现暂时设为下一个要进行作业



                for(j=2;j<5;j++)//找出作业最优

                {

                    if((p[j].sort==0) &&(p[j].submit<=starttime))

                    {

                        if(pmin>p[j].priority)

                        {

                            pmin=p[j].priority;

                            s=j;

                        }

                    }

                }



            //比较完成后，开始运行

           p[s].sort=i;

           p[s].starttime=starttime;

           endtime=starttime+p[s].runtime;

           p[s].endtime=endtime;

           p[s].Turnaround=endtime-p[s].submit;

           p[s].Wturnaround=p[s].Turnaround/p[s].runtime;

           starttime=endtime;



}

}

思想：就是通过比较进程优先级，确定每个进程的优先级，之后进行相应的运算

即if(pmin>p[j].priority) {

    pmin=p[j].priority;

    s=j；

 }

p[s].sort=i;;

p[s].starttime=starttime;……//确定开始运行下一进程的进程编号，将进程结构体的数据更新

3.短作业(JSF)void Sjfprocess(struct process p[])

void Sjfprocess(struct process p[]){

    int i=0,j=0;

    int s=1;

    float runtime=0;

    float starttime=0;

    float endtime=0;

    for(i=1;i<5;i++ )

        {

                if(i==1)//初始化提交时间最早的调度为第一个调度

                {

                    starttime=p[i].submit;

                    for(j=2;j<5;j++)

                    {

                        if(starttime>p[j].submit){

                                starttime=p[j].submit;

                                s=j;//优先级s=提交时间最早的p的序号;

                        }

                    }

                }

                else

                {

                    for(j=2;j<5;j++)//找出没有运行的调度

                    {

                        if((p[j].sort==0) &&(p[j].submit<=starttime))//未运行的且提交时间已经到的

                        {

                            runtime=p[i].runtime;

                            s=j;

                            break;//跳出循环

                        }

                    }



                    for(j=2;j<5;j++)//找出段作业最优调度

                    {

                        if((p[j].sort==0) &&(p[j].submit<=starttime))

                        {

                            if(runtime>p[j].runtime)

                            {

                                s=j;

                            }



                        }

                    }

            }

            //比较完成后，开始运行

           p[s].sort=i;

           p[s].starttime=starttime;

           endtime=starttime+p[s].runtime;

           p[s].endtime=endtime;

           p[s].Turnaround=endtime-p[s].submit;

           p[s].Wturnaround=p[s].Turnaround/p[s].runtime;

           starttime=endtime;

        }

}

思想：比较在未运行的作业中选择运行时间最短的作业

即：if(runtime>p[j].runtime){s=j;}//比较选出算法的作业

p[s].priority=i;……//将运行次序填上，计算其他相应数据

4.响应比高者(HRRN)void Hrrnprocess(struct process p[])

void Hrrnprocess(struct process p[]){

    int i=0,j=0;

    int s=1;

    float respone=0;//响应比

    float starttime=0;

    float endtime=0;



    for(i=1;i<5;i++ ){

                if(i==1)//初始化模拟数据提交时间最早的调度为第一个调度，后来思考认为实际调度，第一个调度就为提交时间最早的，因此一号进程为第一个运行

                {

                   s=i;

                   starttime=p[i].submit;

                }

                else

                {

                    for(j=2;j<5;j++)//找出没有运行的调度,第一个进程不用比较

                    {

                        if((p[j].sort==0) &&(p[j].submit<=starttime))//符合则为下一个调度

                        {

                            respone=(starttime-p[j].submit+p[j].runtime)/p[j].runtime;//（等待时长+运行时长）/运行时长

                            s=j;

                            break;//跳出循环

                        }

                    }



                    for(j=2;j<5;j++)//找出响应比高的作业最优调度

                    {

                        if((p[j].sort==0) &&(p[j].submit<=starttime))//未运行的且提交时间已经到的

                        {

                            float rs=(starttime-p[j].submit+p[j].runtime)/p[j].runtime;

                            if(respone<rs)

                            {

                                respone=rs;

                                s=j;

                            }



                        }

                    }

            }

            //比较完成后，开始运行

           p[s].sort=i;

           p[s].starttime=starttime;

           endtime=starttime+p[s].runtime;

           p[s].endtime=endtime;

           p[s].Turnaround=endtime-p[s].submit;

           p[s].Wturnaround=p[s].Turnaround/p[s].runtime;

           starttime=endtime;



    }

}

思想：在未运行的作业中选择一个响应比最高的作业进行作业

即：float rs=(starttime-p[j].submit+p[j].runtime)/p[j].runtime;

if(respone<rs)

{

respone=rs;

    s=j;

}

五、运行结果

1.先来先服务调度(FCFS)

2.优先调度(Priority Scheduling)

3.短作业调度(Shortest Job First)

4.响应比高者优先调度(Highest Response Ratio Next)

奋斗的蜗牛小猿
关注
  • 0
    点赞
  • 踩
  • 23
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
操作系统Linux实验报告四：LINUX进程调度与系统监视.doc
07-13
操作系统Linux实验报告四：LINUX进程调度与系统监视.doc
优先级调度算法实现_Linux内核浅析-进程调度的算法和数据结构
weixin_39824191的博客
11-21 545
说到进程调度，还是很难说清楚的问题，网上的文章虽然汗牛充栋，但我觉得缺少重点且篇幅比较冗余。我争取抓住重点，以较短的篇幅讲清楚。1、进程优先级和分类进程优先级代表进程需要运行的紧急程度和需要更多的运行时间片，Linux的优先级的范围是[0, 139]，数值越小，优先级越高。用户态通过nice值设置优先级，nice值的范围是[-20,19]，其映射到范围100~139。setpriority系统调用...
操作系统实验1：Linux常用命令及简单C语言程序调试
最新发布
qq_61814350的博客
05-20 897
经过这次实验我学习了如何用VMware在真实机上创建一台Linux虚拟机，并学习了使用vi编辑器编辑一个c语言源程序，并用gcc对源程序进行编译以及运行生成的可执行文件。安装了Linux下的可视化调试工具Code::blocks并熟悉了它的基础使用方式。
《Linux操作系统编程》第二章 进程运行与调度: 了解进程的定义与特征、进程的状态与切换、进程管理的数据结构、进程的创建与终止、阻塞与唤醒、挂起与激活以及处理机调度的相关概念
猫头虎：授渔优于赠鱼，兴趣引领智慧，探索之乐尤显珍贵。商务合作：Libin9iOak，共赴知识与乐趣的探索之旅！
06-29 291
《Linux操作系统编程》第二章 进程运行与调度: 了解进程的定义与特征、进程的状态与切换、进程管理的数据结构、进程的创建与终止、阻塞与唤醒、挂起与激活以及处理机调度的相关概念
一步一步学linux操作系统: 12 进程调度一_调度策略与调度类介绍
墨1024
06-28 902
进程调度、调度策略与调度类介绍、
进程模拟调度实验
weixin_46696469的博客
04-06 5456
实验三 进程模拟调度实验 一、实验目的 多道系统中，当就绪进程数大于处理机数时，须按照某种策略决定哪些进程优先占用处理机，本实验模拟实现处理机调度，以加深了解处理机调度的工作 二、实验内容 选择一个调度算法，实现处理机调度。 三、实验要求 1、设计一个按下面三种调度算法实现处理机调度的程序。 1）先来先服务 2）短进程优先或优先权高优先 3）按时间片轮转 2、说明：PCB内容： 进程名/PID 、要求运行时间（单位时间）、优先权、状态 、到达时间、已用CPU时间等。 1） 可随机输入.
【作业调度的常见算法解析】
m0_47163275的博客
07-24 842
作业调度的常见算法： 最容易想到，最简单的，就是先来先服务算法，它的本质，其实是按等待时间来进行调度，谁先来，先运行，看起来比较合理，但是，这种调度策略，没有从系统的角度去考虑，大家可以想象一下，我们去银行办理业务，排队，如果第一个人是大作业，办理时间很长，导致一上午，可能办理不了多少人的业务，在我们操作系统里，称为吞吐量低，从系统的角度看，吞吐量小，完成的任务数少，所以，我们总结一下。 先来先服务算法，它的好处是，大作业可以得到运行，但吞吐量小。为了提高吞吐量我们很容易想到—小作业优先，这样，完成的任务就
操作系统课设-进程互斥与调度
11-21
在这个操作系统课程设计中，学生们被要求深入理解并发执行的原理，并通过编程实践来解决进程间的资源竞争问题，同时掌握两种关键的调度算法——时间片轮转和优先权调度。 首先，进程互斥是确保同一时刻只有一个进程...
操作系统实验三 进程调度算法实验
05-14
操作系统实验三的主题是“进程调度算法实验”，旨在深入理解进程调度的概念，体验其工作机制，并学习如何在Linux系统中应用不同的调度策略。实验报告涵盖了三种主要的调度方法：SCHED_OTHER、SCHED_FIFO和SCHED_RR。...
进程实验_Linux系统进程实验_
09-30
在IT领域，尤其是在操作系统的学习和实践中，Linux系统进程实验是一个重要的环节。进程是操作系统资源分配的基本单位，理解并掌握进程的创建、管理以及通信对于深入理解操作系统的工作原理至关重要。在这个实验中，...
实验2-进程调度的操作1
08-08
实验“进程调度的操作1”是Linux操作系统课程中的一个实践环节，旨在帮助学生深入理解进程的概念，熟悉进程管理机制，特别是掌握如何使用命令进行进程及其状态的控制，以及如何利用cron进行计划任务的设置和管理。...
Linux实践——CPU调度算法实现
weixin_47692652的博客
03-28 2826
Linux实践——CPU调度算法实现
linux进程的调度
m0_65931372的博客
07-31 4881
进程状态 进程主要有7种状态：就绪状态、运行状态、轻度睡眠、中度睡眠、深度睡眠、僵尸状态、死亡状态。它们之间状态变迁如下： 进程描述符task_struct结构体中有个成员state专门用来描述进程的状态。 就绪状态：state为TASK_RUNNING，正在运行队列中等待调度器调度。 运行状态：state为TASK_RUNNING，被调度器命中，正在处理器中运行。 轻度睡眠：称为可打断的睡眠状态。state为TASK_INTERRUPTIBLE，可以被信号打断。 中度睡眠：state为TASK_KIL
Linux进程管理实验
weixin_45821518的博客
04-07 485
将生成的C语言源文件编译成二进制可执行文件.o。在这里插入图片描述https//img−blogcsdnimgcn/55b1b7981e97464299dea8319cb037c9.png若运行失败，先安装gcc编辑器：运行pro1.o$./pro1.o。
吉林大学操作系统上机（实验一：Linux进程与线程通讯）
热门推荐
KQ的博客
07-07 2万+
菜鸡博客，只是作为学习记录。。。操作系统要好好学！ 1. 上机准备 建议提前弄，这个起码2个小时，因为我们老师建议我们在VMware Workstation上运行Red Hat Linux，并学会gcc编程，所以以下教程都是为了实现这个。 一些概念： 虚拟机：是通过软件模拟出虚拟系统，该系统可以模拟真实计算机所拥有的全部配置和相关功能。 VMware Workstation是一款桌面虚拟计算软件，提供虚拟机的功能，可以同时运行多个不同的操作系统。 Linux 是一款免费的开源操作系统，设计与 UNIX 类
Linux系统中的进程调度算法
scmuzi18的博客
02-19 2087
     在操作系统中，调度是指一种资源分配，因而调度算法是指：根据系统的资源分配策略所规定的资源分配算法，对于不同的系统和系统目标，通常采用不同的调度算法。以下就Linux的进程调度算法加以解释。     一、以下算法用于实时系统       1、  时间片轮转调度算法(round-robin):SCHED_RR，系统使每个进程依次地按时间片轮流执行的方式。该算法的基本思想是，将CPU
Linux编程：模拟进程调度算法
考拉研究僧的博客
12-10 8379
稍稍有点操作系统基础的朋友应该知道进程的调度算法，在这里Koala还是给大家略微介绍一下接下来将要用到的几种算法： 先来先服务（FCFS） 采用FCFS调度，先请求CPU的进程会先分配到CPU。 使用FCFS调度的等待时间通常较长，CPU利用率也会较低 最短作业优先调度（SJF） 采用SJF调度会选择具有最短CPU运行时间的进程分配CPU使用权。如果两个进程的CPU区间相同，则按照FCFS来进
Linux进程调度CFS算法实现分析
三哥的技术专栏
01-03 1171
网上讲CFS的文章很多，可能版本不一，理解不尽相同。我以问题追溯方式，跟踪源码写下我对CFS的理解，有的问题我也还没理解透，欢迎对内核有兴趣的朋友一起交流学习，源码版本是与LKD3配套的Linux2.6.34 背景知识： (1) Linux的调度器类主要实现两类进程调度算法：实时调度算法和完全公平调度算法(CFS)，实时调度算法SCHED_FIFO和SCHED_RR
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

奋斗的蜗牛小猿

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值