Bootstrap

进程调度算法的模拟实现

【实验目的】

1.理解和掌握课堂上讲的进程调度算法，并编程模拟实现调度过程。
2.研究进程调度算法的实现方法，并对算法性能参数进行对比。

【实验要求】

编程模拟实现传统的进程调度算法：FCFS调度算法、SPF调度算法、RR调度算法、优先级调度，高响应比优先等算法。

/*FCFS 和 SPF 调度算法*/
#include<iostream>
#include<cstdio>
#include<cstdlib>
#include<cmath>
#include<cstring>
#include<algorithm>
using namespace std;
/*进程控制块*/
typedef struct{
	char pname;//进程名
	int arrive_t;//到达时间
	int service_t;//服务时间
	int finish_t;//完成时间
	int turnaround_t;//周转时间
	double w_turnaround_t;//带权周转时间
}PCB;

PCB p[20]; //声明n个进程控制块
int n=5;
/*初始化进程信息：进程名、到达时间、服务时间、状态*/
void init();
/*输出初状态*/
void original_P();
//排序
bool cmp1(PCB a,PCB b);
bool cmp2(PCB a,PCB b);
bool cmp3(PCB a,PCB b);
bool cmp4(PCB a,PCB b);
/*FCFS算法*/
void FCFS_work();
/*SPF算法*/
void SPF_work();
/*输出最终状态*/
void Print();
int main()
{
	init();
	original_P();
	char op;
	printf("请输入要使用的调度算法(<f/F-->FCFS> <s/S-->SPF>):");
	scanf("%c",&op);
	getchar();
	if(op=='s'||op=='S')
	{
		SPF_work();
	}
	if(op=='f'||op=='F')
	{
		FCFS_work();
	}
	Print();
	return 0;
}

void init()//初始化进程信息：进程名、到达时间、服务时间
{
	p[0].pname = 'A';
	p[0].arrive_t = 0;
	p[0].service_t = 3;
	
	p[1].pname = 'B';
	p[1].arrive_t = 2;
	p[1].service_t = 6;
	
	p[2].pname = 'C';
	p[2].arrive_t = 4;
	p[2].service_t = 4;
	
	p[3].pname = 'D';
	p[3].arrive_t = 6;
	p[3].service_t = 5;
	
	p[4].pname = 'E';
	p[4].arrive_t = 8;
	p[4].service_t = 2;
}
void original_P()//输出初始状态
{
	printf("进程初始状态\n");
	printf("------------------------------------------------------------------\n");
	printf("进程名\t\t到达时间\t服务时间\n");
	int i;
	for(i=0;i<n;i++)
	{
		printf("%c\t\t    %d\t\t    %d\n",p[i].pname,p[i].arrive_t,p[i].service_t);
	}
	printf("--------------------------------------------------------------------------------------------------\n");
 }
 bool cmp1(PCB a,PCB b)
{
    return a.arrive_t<b.arrive_t;//按到达时间从小到达排序
}
 void FCFS_work()
{
    sort(p,p+n,cmp1);
    p[0].finish_t=p[0].arrive_t+p[0].service_t;//第一个进程的完成时间=到达时间+服务时间
    for(int i=1;i<n;i++)
    {
        p[i].finish_t=max(p[i].arrive_t,p[i-1].finish_t)+p[i].service_t;//完成时间=开始运行时间+服务时间
    }

}

 //按先达到时间排序，再按服务时间排序
 bool cmp2(PCB a,PCB b)
 {
     if(a.arrive_t==b.arrive_t)
     {
         return a.service_t<b.service_t;
     }
     else
     {
         return a.arrive_t<b.arrive_t;
     }
 }
 //按服务时间排序
 bool cmp3(PCB a,PCB b)
 {
     return a.service_t<b.service_t;
 }
void SPF_work()
{
    sort(p,p+n,cmp2);//先按到达时间排序，再按进程服务时间排序
    p[0].finish_t=p[0].arrive_t+p[0].service_t;//第一个进程的完成时间=到达时间+服务时间
    int cnt=1;//判断完成时间内到达的进程个数,设第一个进程已经到达
    for(int i=1;i<n;i++)//看每一个进程 
    {
        if(cnt<n)
        {
             for(int j=i;j<n;j++)//看后面来的进程 
            {
                if(p[j].arrive_t<=p[i-1].finish_t)//比较到达时间和上一个进程的完成时间 
                {
                    cnt++;//如果已经达到就标记 
                }
                else
                    break;
            }
            if(cnt>i)//需要排序时 
                sort(p+i,p+cnt,cmp3);//按服务时间排序
        }
        p[i].finish_t=max(p[i-1].finish_t,p[i].arrive_t)+p[i].service_t;//完成时间 
    }
}
bool cmp4(PCB a,PCB b)
{
	return a.pname<b.pname;//按进程名排序 
}
void Print()
{
	printf("--------------------------------------------------------------------------------------------------\n");
	int i;
	printf("进程执行顺序为：\n");
	for(i=0;i<n;i++)
    {
        printf("%c ",p[i].pname);
    }
    printf("\n");
    sort(p,p+n,cmp4);
	printf("--------------------------------------------------------------------------------------------------\n");
	printf("进程名\t\t到达时间\t服务时间\t完成时间\t周转时间\t带权周转时间\n");
	int sum_t1=0;//代表总的周转时间
	double sum_t2=0;//代表总的带权周转时间
	for(i=0;i<n;i++)
	{
		p[i].turnaround_t=p[i].finish_t-p[i].arrive_t;//周转时间=完成时间-到达时间
        p[i].w_turnaround_t=(double)p[i].turnaround_t/p[i].service_t;//带权周转时间=周转时间/服务时间
		sum_t1=sum_t1 + p[i].turnaround_t;
		sum_t2=sum_t2 + p[i].w_turnaround_t;
		printf("%c\t\t    %d\t\t    %d\t\t   %d\t\t   %d\t\t  %0.2f\n",p[i].pname,p[i].arrive_t,
		       p[i].service_t,p[i].finish_t,p[i].turnaround_t,p[i].w_turnaround_t);

	}
	printf("平均周转时间:%0.2f\n",(double)sum_t1/n);
	printf("平均带权周转时间:%0.2f\n",(double)sum_t2/n);

}


//高响应比优先调度算法
#include<iostream>
#include<cstdio>
#include<cstdlib>
#include<cmath>
#include<cstring>
#include<algorithm>
using namespace std;
/*进程控制块*/
typedef struct{
	char pname;//进程名
	int arrive_t;//到达时间
	int service_t;//服务时间
	int finish_t;//完成时间
	int turnaround_t;//周转时间
	double w_turnaround_t;//带权周转时间
	double r;//响应比
}PCB;

PCB p[20]; //声明进程控制块
int n=6;
void init()//初始化进程信息：进程名、到达时间、服务时间
{
	p[0].pname = 'A';
	p[0].arrive_t = 0;
	p[0].service_t = 3;

	p[1].pname = 'B';
	p[1].arrive_t = 2;
	p[1].service_t = 4;

	p[2].pname = 'C';
	p[2].arrive_t = 3;
	p[2].service_t = 2;

	p[3].pname = 'D';
	p[3].arrive_t = 4;
	p[3].service_t = 5;

	p[4].pname = 'E';
	p[4].arrive_t = 5;
	p[4].service_t = 3;
	
	p[5].pname = 'F';
	p[5].arrive_t = 6;
	p[5].service_t = 6;
}
void original_P()//输出初始状态
{
	printf("进程初始状态\n");
	printf("------------------------------------------------------------------\n");
	printf("进程名\t\t到达时间\t服务时间\n");
	int i;
	for(i=0;i<n;i++)
	{
		printf("%c\t\t    %d\t\t    %d\n",p[i].pname,p[i].arrive_t,p[i].service_t);
	}
 }
bool cmp1(PCB a,PCB b)
{
    return a.arrive_t<b.arrive_t;//按到达时间从小到达排序
}
bool cmp2(PCB a,PCB b)
{
    return a.r>b.r;//按响应比从大到小排序
}

 //高响应比优先调度算法
 void HRRN_work()
 {
    sort(p,p+n,cmp1);//先按到达时间排序
    p[0].finish_t=p[0].arrive_t+p[0].service_t;//第一个进程的完成时间=到达时间+服务时间
    int cnt;//为了计算要排序的响应比对应的进程数
    for(int i=1;i<n;i++)
    {
        cnt=0;
        for(int j=i;j<n;j++)//从当前进程的下一个进程开始看
        {
            if(p[j].arrive_t<=p[i-1].finish_t)//比较到达时间和上一个进程的完成时间
            {
                p[j].r=(double)(p[i-1].finish_t-p[j].arrive_t)/p[j].service_t+1;//计算响应比
                cnt++;

            }
            else //后面的进程还没到，就不计算了
                break;

        }
        sort(p+i,p+i+cnt,cmp2);//只需要排当前进程后面未执行的进程，按响应比由高到低排序，最大的排在前面
        //按响应比最高的执行
        p[i].finish_t=max(p[i-1].finish_t,p[i].arrive_t)+p[i].service_t;//计算进程的完成时间
    }

 }
 bool cmp3(PCB a,PCB b)
{
    return a.pname<b.pname;//按进程名排序 
}
 void Print()
{
    int i;
    printf("进程执行顺序为：\n");
	for(i=0;i<n;i++)
    {
        printf("%c ",p[i].pname);
    }
    printf("\n");
    sort(p,p+n,cmp3);
	printf("--------------------------------------------------------------------------------------------------\n");
	printf("进程名\t\t到达时间\t服务时间\t完成时间\t周转时间\t带权周转时间\n");
	int sum_t1=0;//代表总的周转时间
	double sum_t2=0;//代表总的带权周转时间
	for(i=0;i<n;i++)
	{
	    p[i].turnaround_t=p[i].finish_t-p[i].arrive_t;//周转时间=完成时间-到达时间
        p[i].w_turnaround_t=(double)p[i].turnaround_t/p[i].service_t;//带权周转时间=周转时间/服务时间
		sum_t1=sum_t1 + p[i].turnaround_t;
		sum_t2=sum_t2 + p[i].w_turnaround_t;
		printf("%c\t\t    %d\t\t    %d\t\t   %d\t\t   %d\t\t  %0.2f\n",p[i].pname,p[i].arrive_t,
		       p[i].service_t,p[i].finish_t,p[i].turnaround_t,p[i].w_turnaround_t);

	}
	printf("平均周转时间:%0.2f\n",(double)sum_t1/n);
	printf("平均带权周转时间:%0.2f\n",(double)sum_t2/n);

}
int main()
{
    init();
    original_P();
    HRRN_work();
    Print();
    return 0; 
}

//RR时间片轮转与HPF优先级调度算法
#include<iostream>
#include<cstdio>
#include<cstdlib>
#include<cmath>
#include<cstring>
#include<algorithm>
#include<queue>
using namespace std;
typedef struct{
	char pname;//进程名
	int arrive_t;//到达时间
	int service_t;//服务时间
	int finish_t;//完成时间
	int turnaround_t;//周转时间
	double w_turnaround_t;//带权周转时间
	char state;//进程状态: w：等待， m：就绪，r：运行
	int priority;//优先级
	int run_t;//运行时间
	int remaining_t;//剩余时间
}PCB;
PCB p[20];
int n=10;
char op;
void init()//初始化进程信息：进程名、到达时间、服务时间、状态
{
	p[0].pname = 'A';
	p[0].arrive_t = 0;
	p[0].service_t = 3;
	p[0].priority=2;

	p[1].pname = 'B';
	p[1].arrive_t = 2;
	p[1].service_t = 5;
	p[1].priority=1;

	p[2].pname = 'C';
	p[2].arrive_t = 2;
	p[2].service_t = 2;
	p[2].priority=4;

	p[3].pname = 'D';
	p[3].arrive_t = 4;
	p[3].service_t = 4;
	p[3].priority=3;

	p[4].pname = 'E';
	p[4].arrive_t = 4;
	p[4].service_t = 1;
	p[4].priority=10;

	p[5].pname = 'F';
	p[5].arrive_t = 4;
	p[5].service_t = 4;
	p[5].priority=8;

    p[6].pname = 'G';
	p[6].arrive_t = 6;
	p[6].service_t = 2;
	p[6].priority=9;

	p[7].pname = 'H';
	p[7].arrive_t = 6;
	p[7].service_t = 6;
	p[7].priority=6;

	p[8].pname = 'I';
	p[8].arrive_t = 6;
	p[8].service_t = 5;
	p[8].priority=7;

	p[9].pname = 'J';
	p[9].arrive_t = 6;
	p[9].service_t = 2;
	p[9].priority=5;


	for(int i=0;i<n;i++)
    {
        p[i].state='w';//初始状态都设为等待
        p[i].run_t=0;
        p[i].remaining_t=p[i].service_t;
    }
}
void original_HPF_P()//输出HPF的初始状态
{
	printf("进程的初始状态\n");
	printf("------------------------------------------------------------------\n");
	printf("进程名\t\t到达时间\t服务时间\t优先级(数越大优先级越高)\n");
	int i;
	for(i=0;i<n;i++)
	{
		printf("%c\t\t    %d\t\t    %d\t\t    %d\n",p[i].pname,p[i].arrive_t,p[i].service_t,p[i].priority);
	}
 }
 void original_RR_P()//输出时间片轮转调度算法各进程的初始状态
{
	printf("进程的初始状态\n");
	printf("------------------------------------------------------------------\n");
	printf("进程名\t\t到达时间\t服务时间\n");
	int i;
	for(i=0;i<n;i++)
	{
		printf("%c\t\t    %d\t\t    %d\n",p[i].pname,p[i].arrive_t,p[i].service_t);
	}
 }
//HPF非抢占式优先级调度算法
//比较后面的优先级
bool cmp1(PCB a,PCB b)//先按到达时间排序，再按优先级排序
{
     if(a.arrive_t==b.arrive_t)
     {
         return a.priority>b.priority;//数越大，优先级越高
     }
     else
     {
         return a.arrive_t<b.arrive_t;
     }
}
bool cmp2(PCB a,PCB b)//按优先级排序
{
    return a.priority>b.priority;
}

void HPF_work()
{
    sort(p,p+n,cmp1);//先按到达时间排序，再按优先级排序
    p[0].finish_t=p[0].arrive_t+p[0].service_t;//第一个进程的完成时间=到达时间+服务时间
    int cnt=1;//判断完成时间内到达的进程个数,设第一个进程已经到达
    for(int i=1;i<n;i++)//看每一个进程
    {
        if(cnt<n)
        {
             for(int j=i;j<n;j++)//看后面来的进程
            {
                if(p[j].arrive_t<=p[i-1].finish_t)//比较到达时间和上一个进程的完成时间
                {
                    cnt++;//如果已经达到就标记
                }
                else
                    break;
            }
            if(cnt>i)//需要排序时
                sort(p+i,p+cnt,cmp2);//按优先级排序
        }
        p[i].finish_t=max(p[i-1].finish_t,p[i].arrive_t)+p[i].service_t;//完成时间

    }
}

bool cmp3(PCB a,PCB b)//按到达时间排序
{
    return a.arrive_t<b.arrive_t;//按到达时间从小到达排序
}
//时间片轮转法,新来的进程应该放在就绪队列的末尾
void RR_work()
{
    int q=2;//设时间片=2
    //先按到达时间排序
    sort(p,p+n,cmp3);//把这些进程编号为0-9
    queue<int> ready_q;//就绪队列
    ready_q.push(0);//先把第一个来的放到就绪队列
    //如果到达了，就放在就绪队列中，弹出队首元素
    int temp;
    int now_time=p[0].arrive_t;//从第一个进程到达时间开始算
    int cnt=1;//第一个进程已经处理了，接下来从p[1]开始看。
    int i;
    printf("进程的执行顺序：\n");
    while(1)
    {
        if(!ready_q.empty())//如果不空，队列中有元素，就占用处理机，进入运行状态
        {
            temp=ready_q.front();//取队头元素
            printf("%c ",p[temp].pname);
            ready_q.pop();//弹出队首元素
            p[temp].run_t=p[temp].run_t+q;//运行时间
            now_time=now_time+q;
             //设有10个进程，下标是从0-9,按顺序排好序的，所以是按顺序到达的
            while(cnt<n&&p[cnt].arrive_t<=now_time)
            {
                ready_q.push(cnt);//放入队尾
                p[cnt].state='m';//进入就绪队列
                cnt++;//等待下一个进程的到达
            }
            if(p[temp].run_t<p[temp].service_t)//如果这个进程还没有运行完成，就放到队列尾部
            {

                p[temp].remaining_t=p[temp].service_t-p[temp].run_t;//剩余时间=需要的服务时间-已经运行的时间

                ready_q.push(temp);//当前的这个再次入队，放在队尾
                p[temp].state='m';//状态为就绪态
            }
            else
            {
                now_time=now_time-(p[temp].run_t-p[temp].service_t);
                p[temp].state='f';//已经执行完了
                p[temp].finish_t=now_time;
            }
        }
        for( i=0;i<n;i++)
        {
            if(p[i].state=='m'||p[i].state=='w')//如果还有进程是等待或者就绪态，就继续进行时间片轮转
                break;
        }
        if(i==n)//如果都执行完了
            break;
    }
    printf("\n");
}
bool cmp4(PCB a,PCB b)
{
    return a.pname<b.pname;//按进程名从小到达排序
}
void Print()
{
    int i;
    if(op=='h'||op=='H')
    {
        printf("进程执行顺序为：\n");
        for(i=0;i<n;i++)
        {
            printf("%c ",p[i].pname);
        }
        printf("\n");
    }
    sort(p,p+n,cmp4);
	printf("--------------------------------------------------------------------------------------------------\n");
	printf("进程名\t\t到达时间\t服务时间\t完成时间\t周转时间\t带权周转时间\n");
	int sum_t1=0;//代表总的周转时间
	double sum_t2=0;//代表总的带权周转时间
	for(i=0;i<n;i++)
	{
	    p[i].turnaround_t=p[i].finish_t-p[i].arrive_t;//周转时间=完成时间-到达时间
        p[i].w_turnaround_t=(double)p[i].turnaround_t/p[i].service_t;//带权周转时间=周转时间/服务时间
		sum_t1=sum_t1 + p[i].turnaround_t;
		sum_t2=sum_t2 + p[i].w_turnaround_t;
		printf("%c\t\t    %d\t\t    %d\t\t   %d\t\t   %d\t\t  %0.2f\n",p[i].pname,p[i].arrive_t,
		       p[i].service_t,p[i].finish_t,p[i].turnaround_t,p[i].w_turnaround_t);

	}
	printf("平均周转时间:%0.2f\n",(double)sum_t1/n);
	printf("平均带权周转时间:%0.2f\n",(double)sum_t2/n);

}

int main()
{
    printf("请输入要使用的调度算法(<h/H:HPF> <r/R:RR>):");
    scanf("%c",&op);
    getchar();
    init();

    if(op=='h'|| op=='H')
    {
        original_HPF_P();
        HPF_work();
        Print();
    }
    if(op=='r'||op=='R')
    {
        original_RR_P();
        RR_work();
        Print();
    }
    return 0;
}

详细实验分析和实验报告下载：
https://download.csdn.net/download/QinHebtu/45045191

悦读

道可道，非常道；名可名，非常名。 无名，天地之始，有名，万物之母。 故常无欲，以观其妙，常有欲，以观其徼。 此两者，同出而异名，同谓之玄，玄之又玄，众妙之门。

最新收录
SQL Server SQL语句删除索引
【数据库系列】 Spring Boot 集成 Neo4j 的详细介绍
C++ 【类和对象: 析构函数，拷贝构造函数，运算符重载 --2】
认识Linux——为什么学Linux
安防视频监控平台，国标GB28181视频平台liveweb流媒体平台方案
如何将多个JS文件打包成一个JS文件？
docker 安装etcd
JavaBean的应用
C++多线程类Thread（C++11）
处理响应中的 JSON 格式数据
;