C++操作系统LLF算法实现

提示：文章写完后，目录可以自动生成，如何生成可参考右边的帮助文档

• 前言
• 一、 实验目的
• 二、 实验原理
• 结果截图

提示：这里可以添加本文要记录的大概内容：

提示：以下是本篇文章正文内容，下面案例可供参考

LLF 算法：该算法是根据任务紧急(或松弛)的程度，来确定任务的优
先级。任务的紧急程度愈高，为该任务所赋予的优先级就愈高，以使
之优先执行。例如，一个任务在 200ms 时必须完成，而它本身所需的
运行时间就有 100ms，因此，调度程序必须在 100ms 之前调度执行，
该任务的紧急程度(松弛程度)为 100ms。又如，另一任务在 400ms 时
必须完成，它本身需要运行 150ms，则其松弛程度为 250ms。在实现
该算法时要求系统中有一个按松弛度排序的实时任务就绪队列，松弛
度最低的任务排在队列最前面，调度程度总是选择就绪队列中的队首
任务执行。

!

完成时间 = 开始时间 + 需要运行时间周转时间 = 完成时间 - 到达时间
平均周转时间 = (完成时间 - 到达时间)/进程数
平均带权周转时间 = (周转时间 / 需要运行时间)/进程数

include 
#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include 

using namespace std;
static int MAXCUM = 5;//RR算法-定义进程最多为5个
static int  currentTime = 0;//初始化当前时间为0
#define E 0//表示进程处于End状态
#define W 1//表示进程处于wait状态
static int NameSeed[20] {1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20};
static int flagA = 0;//进程名字标记
static int flagB = 0;
static int timeSlice = 0;//初始化时间片值为0

class process
{
public:
	process(string processName, int runTime, int status)
	{
		this->m_ProcessName = processName;
		this->m_RunTime =  runTime;
		this->m_Status = status;
	}

	string m_ProcessName;
	int m_MinimumTolerance;//最小容忍度
	int m_NeedRunTime;//还需要的运行时间
	int m_HaveRunTime;//已经运行的时间
	int m_RunTime;//运行时间
	int m_Looseness;//松弛度
	int m_Status;//W和E的状态标记
	int m_Deadline;//截止时间
	int m_ArriveTime;
	int m_FinishTime;
	int m_TurnaroundTime;//周转时间
	double m_AuthorityTurnaroundTime;//带权周转时间

	bool operator<( const process &p)const
	{
		return m_ArriveTime

	p.m_Looseness= p.m_Deadline - currentTime - p.m_NeedRunTime;
	return p.m_Looseness;
}
int calcuNeedRunTime(process p, int currentTime)
{
	p.m_NeedRunTime = p.m_RunTime - p.m_HaveRunTime;
	return p.m_NeedRunTime;
}
int calcuMinimumTolerance(process p, int currentTime)
{
	p.m_MinimumTolerance = p.m_Deadline - p.m_NeedRunTime;
	return p.m_MinimumTolerance;
}
int calcuTurnaroundTime(process p)
{
	p.m_TurnaroundTime = p.m_FinishTime - p.m_ArriveTime;
	return p.m_TurnaroundTime;
}
double calcuAuthorityTurnaroundTime(process p)
{
	p.m_AuthorityTurnaroundTime = p.m_TurnaroundTime / p.m_RunTime;
	return p.m_AuthorityTurnaroundTime;
}
void LLF(process p1,process p2)
{
	for (int i = 0; i < 10; i++)
	{

		if (calcuLoose(p1, currentTime) == 0)//立刻执行p1
		{
			cout << " " << p1.m_ProcessName << NameSeed[flagA] << "从"< currentTime)
			{
				p1.m_Status = E;
			}
			else
			{
				p1.m_Status = W;
			}
		
		}
		else if (calcuLoose(p2, currentTime) == 0)//立刻执行p2
		{

			cout << " " << p2.m_ProcessName << NameSeed[flagB] << "从" << currentTime << "执行到";
		
			currentTime = p2.m_Deadline;
			cout << currentTime;
			p2.m_ArriveTime += 50;
			flagB++;
			p2.m_Deadline += 50;
			p2.m_MinimumTolerance = p2.m_Deadline - 25;
			calcuNeedRunTime(p2, currentTime);
			calcuMinimumTolerance(p2, currentTime);
			calcuLoose(p2, currentTime);
			calcuNeedRunTime(p1, currentTime);
			calcuMinimumTolerance(p1, currentTime);
			calcuLoose(p1, currentTime);
			if (p2.m_ArriveTime > currentTime)
			{
				p2.m_Status = E;
			}
			else
			{
				p2.m_Status = W;
			}
		
		}
		else
		{
			while ((calcuLoose(p1, currentTime) < calcuLoose(p2, currentTime)) || p1.m_Status == E)//p1抢占执行
			{

				for (; calcuNeedRunTime(p1, currentTime) != 0; currentTime++)//正在执行p1
				{
					while (currentTime == calcuMinimumTolerance(p2, currentTime))//当p1正在执行但未执行完时，时间达到了p2的最低容忍时间，执行p2
					{

						cout << " " << p2.m_ProcessName << NameSeed[flagB] << "从" << currentTime << "执行到";
					
						currentTime = p2.m_Deadline;
						cout << currentTime;
						flagB++;
						p2.m_ArriveTime += 50;
						p2.m_Deadline += 50;
						p2.m_MinimumTolerance = p2.m_Deadline - 25;
						p2.m_HaveRunTime = 0;
						calcuNeedRunTime(p2, currentTime);
						calcuMinimumTolerance(p2, currentTime);
						calcuLoose(p2, currentTime);
						calcuNeedRunTime(p1, currentTime);
						calcuMinimumTolerance(p1, currentTime);
						calcuLoose(p1, currentTime);
						if (p2.m_ArriveTime > currentTime)
						{
							p2.m_Status = E;
						}
						else
						{
							p2.m_Status = W;
						}
					
						break;
					}
					cout << " " << p1.m_ProcessName << NameSeed[flagA] << "执行";
					cout << "-" << currentTime << " ";
					p1.m_HaveRunTime += 1;
					calcuNeedRunTime(p1, currentTime);
					calcuMinimumTolerance(p1, currentTime);
					calcuLoose(p1, currentTime);

				}
				p1.m_ArriveTime += 20;
				flagA++;
				p1.m_Deadline += 20;
				p1.m_MinimumTolerance = p1.m_Deadline - 10;
				p1.m_HaveRunTime = 0;
				calcuNeedRunTime(p1, currentTime);
				calcuMinimumTolerance(p1, currentTime);
				calcuLoose(p1, currentTime);
				calcuNeedRunTime(p2, currentTime);
				calcuMinimumTolerance(p2, currentTime);
				calcuLoose(p2, currentTime);
				if (p1.m_ArriveTime > currentTime)
				{
					p1.m_Status = E;
				}
				else
				{
					p1.m_Status = W;
				}
			
				break;
			}
			while ((calcuLoose(p2, currentTime) < calcuLoose(p1, currentTime)) || p1.m_Status == E)//p2抢占执行
			{
				for (; calcuNeedRunTime(p2, currentTime) != 0; currentTime++)//正在执行p2
				{
					while (currentTime == calcuMinimumTolerance(p1, currentTime))//当p2正在执行但未执行完时，时间达到了p1的最低容忍时间，执行p1
					{

						cout << " " << p1.m_ProcessName << NameSeed[flagA] << "从" << currentTime << "执行到";
						
						currentTime = p1.m_Deadline;
						cout << currentTime;
						p1.m_ArriveTime += 20;
						flagA++;
						p1.m_Deadline += 20;
						p1.m_MinimumTolerance = p1.m_Deadline - 10;
						p1.m_HaveRunTime = 0;
						calcuNeedRunTime(p1, currentTime);
						calcuMinimumTolerance(p1, currentTime);
						calcuLoose(p1, currentTime);
						calcuNeedRunTime(p2, currentTime);
						calcuMinimumTolerance(p2, currentTime);
						calcuLoose(p2, currentTime);
						if (p1.m_ArriveTime > currentTime)
						{
							p1.m_Status = E;
						}
						else
						{
							p1.m_Status = W;
						}
					
						break;
					}
					cout << " " << p2.m_ProcessName << NameSeed[flagB] << "执行";
					cout << "-" << currentTime << " ";
					p2.m_HaveRunTime += 1;
					calcuNeedRunTime(p2, currentTime);
					calcuMinimumTolerance(p2, currentTime);
					calcuLoose(p2, currentTime);

				}
				p2.m_ArriveTime += 50;
				flagB++;
				p2.m_Deadline += 50;
				p2.m_MinimumTolerance = p2.m_Deadline - 25;
				p2.m_HaveRunTime = 0;
				calcuNeedRunTime(p2, currentTime);
				calcuMinimumTolerance(p2, currentTime);
				calcuLoose(p2, currentTime);
				calcuNeedRunTime(p1, currentTime);
				calcuMinimumTolerance(p1, currentTime);
				calcuLoose(p1, currentTime);
				if (p2.m_ArriveTime > currentTime)
				{
					p2.m_Status = E;
				}
				else
				{
					p2.m_Status = W;
				}
			
				break;
			}
		}
	}
}

int CompareRunTime(vector v)
{

		sort(v.begin(), v.end(), greater());//sort默认升序排序，加greater后变为降序排序
		return v[0];
}

int main()
{
	//LLF算法部分
	cout << "--------------LLF算法部分-----------" << endl;
	currentTime = 0;//初始化时间片为0
	process A("进程A",10,W);//初始化进程名字 进程的运行时间 进程的状态
	process B("进程B",25,W);
	A.m_Deadline = 20;
	B.m_Deadline = 50;
	A.m_Looseness = 10;
	B.m_Looseness = 25;
	A.m_HaveRunTime = 0;
	B.m_HaveRunTime = 0;
	A.m_NeedRunTime = 10;
	B.m_NeedRunTime = 25;
	A.m_MinimumTolerance = 10;
	B.m_MinimumTolerance = 25;
	A.m_ArriveTime = 0;
	B.m_ArriveTime = 0;

	LLF(A, B);
	system("pause");
	return 0;

结果是丑了点~~~，但是代码是自己纯手写，无任何抄袭，结果保证是对的。
部分代码看不懂的，应该是对英文命名规则不了解，可以自己翻译下就好理解了。