操作系统——进程调度算法（C++）
操作系统——进程调度算法【FCFS：先到先服务，SJF：短进程优先，PSA：优先权调度算法， RR：时间⽚轮转调度算法】
1. 实验⽬的：
多道系统中，当就绪进程数⼤于处理机数时，须按照某种策略决定哪些进程优先占⽤处理机，本实验模拟实现处理机调度，以加深了解处理机调度的⼯作
2. 实验内容：
选择⼀个调度算法，实现处理机调度。
FCFS(先到先服务)，SJF(短进程优先) ，PSA(优先权调度算法)， RR(时间⽚轮转调度算法)
3. 源代码：
以下为代码架构
#include <iostream>
#include<string.h>
//#include <queue>
//#include <time.h>
#define RE 'r'
#define R 'R'
#define F 'F'    //RE(ready)：就绪  R(running)：执⾏  F(finished)：完成
using namespace std;
typedef struct
{
//PCB内容：
char Pid[10];//进程名/PID
float time;//要求运⾏时间（单位时间）
int Priority;//优先级（L：链表长度）个⼈规定：Priority越⼩，优先级越⾼
char state;//状态  RE(ready)：就绪  R(running)：执⾏  F(finished)：完成
float arrival_time;//到达时间
float StartTime;//开始时间
float EndTime;//结束时间（L：最早到达的进程时间）
//float used_time;//已⽤CPU时间
}PCB;
typedef struct node
{
PCB data;
struct node *next;
}Lnode,*Llist;
void PrintPCB(Llist L)//代码完整
{
//cout<<"\n\tPrintPCB()\n";
//cout<<"\n\t进程名\t要求运⾏时间\t优先权\t状态\t到达时间\t开始时间\t结束时间\t已⽤CPU时间\n";
Llist p;
Llist p;
p = L->next;
while(p)
{
cout<<'\t'<<p->data.Pid<<"\t"<<p->data.time<<"\t\t"<<p->data.Priority<<"\t"<<p->data.state <<"\t"<<p->data.arrival_time<<"\t\t"<<p->data.StartTime<<"\t \t"<<p->data.EndTime<<endl;
p = p->next;
}
cout<<"\n\n";
}
void CreateProcess(Llist &L)//尾插法代码完整
{
cout<<"\n\tCreateProcess()\n";
L =new Lnode;
L->next =NULL;
Llist r, s;
s = L;
int n;//链表长度
cout<<"输⼊要创建的进程个数：";
cin>>n;
L->data.Priority = n;
//L->data.EndTime = 9999;
cout<<"输⼊"<<n<<"⾏以下信息：\n进程名\t要求运⾏时间\t优先权\t到达时间\n";
for(int i=0; i<n; i++)
{
r =new Lnode;
//PCB内容：
cin>>r->data.Pid>>r->data.time>>r->data.Priority>>r->data.arrival_time;
r->data.state = RE;//RE(ready)：就绪  R(running)：执⾏  F(finished)：完成
r->data.StartTime =0;
r->data.EndTime =0;
/*if( r->data.arrival_time < L->data.EndTime )
L->data.EndTime = r->data.arrival_time;
r->data.used_time = 0;*/
s->next = r;
s = r;
}
s->next =NULL;
/
*
if(L->data.EndTime == 9999)
L->data.EndTime = 1;
*/
cout<<"\n\t进程名\t要求运⾏时间\t优先权\t状态\t到达时间\t开始时间\t结束时间\n";
PrintPCB(L);
}
//代码完整的三个Exchange()函数
void Exchange(char*a,char* b)//交换
{
char c;
c =*a;
*a =*b;
*b = c;
}
void Exchange(int*a,int* b)//交换
{
//cout<<"\n\tExchange(int)\n";
int c;
c =*a;
c =*a;
*a =*b;
*b = c;
}
void Exchange(float*a,float* b)//交换
{
//cout<<"\n\tExchange(float)\n";
float c;
c =*a;
*a =*b;
*b = c;
}createprocessa
void sort_list(Llist &L,int change=1,int direction=1)//单链表排序，direction>0：升序（默认）；否则，降序
{//1.float time；要求运⾏时间（默认）    2.int Priority；优先级（链表长度）    3.float arrival_time；到达时间
//代码空缺
}
void PrintP(Llist p)//代码完整
{
//cout<<"\n\tPrintP()\n";
cout<<'\t'<<p->data.Pid<<"\t"<<p->data.time<<"\t\t"<<p->data.Priority<<"\t"<<p->data.state <<"\t"<<p->data.arrival_time<<"\t\t"<<p->data.StartTime<<"\t\t" <<p->data.EndTime<<endl;
}
void classify( Llist &will_waiting, Llist &waiting,float cputime)//从will_waiting（cputime之外的进程结点）中，选取结点插⼊waiting（cputime时间之内）
{
//代码空缺
}
void FCFS(Llist L)//先到先服务，按3.arrival_time（到达时间）升序排序
{
//代码空缺
}
void SJF(Llist L)//短进程优先，按1.time（要求运⾏时间（单位时间））升序排序
{
//该算法基本与PSA(Llist L)（优先级调度算法）相同，时间问题就不写了
}
void PSA(Llist L)//优先级调度算法(⾮抢占⽅式)，个⼈规定：Priority越⼩，优先级越⾼按2.Priority；优先级（链表长度）升序排序
{
//代码空缺
}
void RR(Llist L)//时间⽚轮转调度算法（遵循FCFS），优先级⾼的先服务，相同时FCFS  个⼈规定：Priority越⼩，优先级越⾼，所以优先权降⼀级为：Priority ++
{
//代码空缺
}
int main()//代码完整
{
int flag =1;//退出标志
char a;//选项
Llist L;
CreateProcess(L);
//PrintPCB(L);
while(flag)
{
cout<<"*********************************************"<<endl;
cout<<("\t F. FCFS(先到先服务) \n");
//cout<<("\t S. SJF(短进程优先) \n");
cout<<("\t P. PSA(优先权调度算法) \n");
cout<<("\t R. RR(时间⽚轮转调度算法) \n");
cout<<("\t Q. EXIT(退出) \n");
cout<<"*********************************************"<<endl;
cout<<"输⼊想要的操作：";
cin>>a;
strupr(&a);
cout<<"\n\t进程名\t要求运⾏时间\t优先权\t状态\t到达时间\t开始时间\t结束时间\n";
switch(a)
{
case'Q':
flag=0;
break;
case'F':
FCFS(L);
break;
/*case 'S':
SJF(L);
break;*/
case'P':
PSA(L);
break;
case'R':
RR(L);
break;
default:
cout<<"error！"<<endl;
break;
}
}
return0;
}
4 测试数据：
输⼊格式：
3
a 3 2 1
e 4 3 1
r 3 2 2
5 运⾏结果

版权声明：本站内容均来自互联网，仅供演示用，请勿用于商业和其他非法用途。如果侵犯了您的权益请与我们联系QQ:729038198，我们将在24小时内删除。