五种进程调度的算法实现（三）

实验要求

完成进程调度的可视化。

包括六种调度算法：

public enum SchdType
{
[Description("先来先服务")]
FCFS,
[Description("最短作业优先")]
SJF,
[Description("最短剩余时间优先")]
SRTF,
[Description("最高响应比优先")]
HRRF,
[Description("优先级调度")]
PRIOR,
[Description("轮转调度")]
RR,
}

设计思路

使用C# WindowsForm易于开发。

调度算法基于LINQ；

所有调度算法采用统一的接口；

用DataGridView呈现和更改初始数据；

用GDI+实现绘图。

数据结构

初始数据结构：

public class SimpleTask
{
[Unique]
[DefaultValue("Task")]
[Description("作业名")]
public string Name { set; get; }

[DefaultValue(0)]
[Description("开始时间")]
public int StartTime { set; get; }

[DefaultValue(1)]
[Description("运行时间")]
public int ExecuteTime { set; get; }

[DefaultValue(0)]
[Description("优先级")]
public int Priority { set; get; }
}

初始化：

void InitTestData()
{
data.Rows.Add(new object[] { "A", 0, 3, 5 });
data.Rows.Add(new object[] { "B", 2, 6, 2 });
data.Rows.Add(new object[] { "C", 4, 4, 3 });
data.Rows.Add(new object[] { "D", 6, 5, 4 });
data.Rows.Add(new object[] { "E", 8, 2, 1 });
}

运行时调度结构：

public class SchdRestModel
{
public SimpleTask task { set; get; }

public int rest { set; get; }//剩余运行时间

public double temp { set; get; }//用于存储响应比
}

输入输出结构：

public class SimulationResult
{
public List<SimpleTask> tasks { set; get; }

public List<string> cpu_clips { set; get; }
}

可视化结构：

public class VisualStruct
{
public DuringStruct during { set; get; }

public List<Tuple<int, int>> cpu_clips { set; get; }
}

public class VisualData
{
public Dictionary<string, VisualStruct> visual { set; get; }

public List<int> switches { set; get; }
}

参数设置：

public class SchdSettings
{
private static int _TimeSpan = 1;

public static int TimeSpan { set { _TimeSpan = value; } get { return _TimeSpan; } }

public static readonly int MaxTimeSpan = 10;
public static readonly int MinTimeSpan = 1;
}

public class VisualSettings
{
public static readonly int TimeSpanWidth = 30;
public static readonly int TaskHeight = 30;
public static readonly int TaskSpacing = 20;
public static readonly int TaskBlanking = 20;
public static readonly int TimeHeight = 20;
public static readonly int DegreeHeight = 5;
public static readonly int DispTextWidth = 100;
public static readonly int Margin = 5;
}

设计实现

一、接口及抽象类

调度接口：

public interface IProcessSchd
{
void ImportData(IEnumerable<SimpleTask> tasks);

void SetCallback(Action<string> action);

SimulationResult Simulate();
}

抽象基类：

public abstract class ProcessSchd : IProcessSchd
{
protected IEnumerable<SimpleTask> origin_tasks;
protected Action<string> action;

public void ImportData(IEnumerable<SimpleTask> tasks)
{
origin_tasks = tasks;
}

public void SetCallback(Action<string> action)
{
this.action = action;
}

public abstract SimulationResult Simulate();
}

工厂模式构建：

public class SchdFactory
{
static public IProcessSchd CreateSchdInstance(SchdType type)
{
return Assembly.GetExecutingAssembly().CreateInstance("SimuProcessSchd.Schd" + type.ToString()) as IProcessSchd;
}
}

二、通用算法

2.1 通用算法版本一（适用于除轮转调度以外的五种调度算法）

/// <summary>
/// 通用调度算法版本一
/// </summary>
/// <param name="task">运行时处理队列</param>
/// <param name="blocked">是否独占式调度（非剥夺）</param>
/// <param name="select">自定义任务竞取函数</param>
/// <returns></returns>
static public List<string> GetSimuResultDirectV1(IEnumerable<SchdRestModel> task, bool blocked, Func<IEnumerable<SchdRestModel>, int, IEnumerable<SchdRestModel>> select)
{
var list = new List<string>();//用于存放结果
var new_list = task.ToList();//当前任务队列的拷贝，用于调度
IEnumerable<SchdRestModel> selected = null;
for (int i = 0; new_list.Count() > 0; i++)//进行运行时调度，当前队列为空时结束
{
//当规定为可剥夺时，初始化任务竞取函数，用于选取下一任务
if (!blocked || (blocked && selected == null))
selected = select(new_list, i);
if (selected.Count() > 0)//可以选取下一任务
{
var running = selected.First();//取下一任务队列头
list.Add(running.task.Name);//当前时刻处理该任务并记录任务名
if (running.rest > 1)//当前任务还有剩余运行时间
{
//当前运行的任务的剩余时间减一
new_list.Find(a => a.task.Name == running.task.Name).rest--;
}
else//当前任务已完成
{
if (selected != null)
selected = null;//清空竞取函数
//从调度队列中除去该任务
new_list.RemoveAll(a => a.task.Name == running.task.Name);
}
}
else//已经没有任务可选取，收尾工作
{
if (selected != null)
selected = null;
list.Add(null);
}
}
return list;
}

2.2 通用算法版本二（只适用于轮转调度）

/// <summary>
/// 通用调度算法版本二
/// </summary>
/// <param name="task">起始的任务队列</param>
/// <returns>模拟调度结果</returns>
static public List<string> GetSimuResultDirectV2(IEnumerable<SchdRestModel> task)
{
var list = new List<string>();
//采用双队列，后备和轮转
var backup = task.ToList(); // 后备队列
var round = new List<SchdRestModel>(); // 轮转队列
//当双队列都不为空时，继续运行，i为时刻
for (int i = 0; backup.Count > 0 || round.Count > 0; i++)
{
SchdRestModel current = null;

// 检查后备
if (round.Count == 0)//当前轮转队列为空时，取后备队列
{
round.AddRange(
from x in backup
where x.task.StartTime <= i
orderby x.task.StartTime//按起始时间
orderby x.task.Priority//按优先级
select x);
backup.RemoveAll(a => a.task.StartTime <= i);//做移动操作，将旧的删除
}

// 处理轮转
if (round.Count > 0)//轮转不为空，则有任务
{
current = round.First();//取队列头
round.RemoveAt(0);//清除
}

// 取出队头并处理
if (current != null)
{
var min = Math.Min(current.rest, SchdSettings.TimeSpan);//轮转时独占时长的限制
current.rest -= min;//减去当前运行时间
for (int j = 0; j < min; j++)
{
list.Add(current.task.Name);//添加运行记录
}
if (current.rest <= 0)
{
current = null;//没有剩余时间则丢弃
}
i += min - 1;//时刻表推进，由于for循环对i有自增操作，所以这里减一
}
else
{
list.Add(null);//结束标记
}

// 再次处理后备
{
round.AddRange(
from x in backup
where x.task.StartTime <= i + 1
orderby x.task.StartTime
orderby x.task.Priority
select x);
backup.RemoveAll(a => a.task.StartTime <= i + 1);
}

// 将当前任务放至队尾
if (current != null)
{
round.Add(current);
}
}
return list;
}

三、具体算法

/// <summary>
/// 先来先服务
/// </summary>
public class SchdFCFS : ProcessSchd
{
public override SimulationResult Simulate()
{
var result = new SimulationResult() { tasks = origin_tasks.ToList() };
result.cpu_clips = SchdImplHelper.GetSimuResultDirectV1(
from x in origin_tasks
orderby x.StartTime
select new SchdRestModel
{
task = x,
rest = x.ExecuteTime,
},
true,
(a, i) =>
from x in a
where x.task.StartTime <= i
select x
);
return result;
}
}

/// <summary>
/// 最短作业优先
/// </summary>
public class SchdSJF : ProcessSchd
{
public override SimulationResult Simulate()
{
var result = new SimulationResult() { tasks = origin_tasks.ToList() };
result.cpu_clips = SchdImplHelper.GetSimuResultDirectV1(
from x in origin_tasks
orderby x.StartTime
select new SchdRestModel
{
task = x,
rest = x.ExecuteTime,
},
true,
(a, i) =>
from x in a
where x.task.StartTime <= i
orderby x.task.ExecuteTime
select x
);
return result;
}
}

/// <summary>
/// 最短剩余时间优先
/// </summary>
public class SchdSRTF : ProcessSchd
{
public override SimulationResult Simulate()
{
var result = new SimulationResult() { tasks = origin_tasks.ToList() };
result.cpu_clips = SchdImplHelper.GetSimuResultDirectV1(
from x in origin_tasks
orderby x.ExecuteTime
select new SchdRestModel
{
task = x,
rest = x.ExecuteTime,
},
false,
(a, i) =>
from x in a
where x.task.StartTime <= i
orderby x.rest
select x
);
return result;
}
}

/// <summary>
/// 最高响应比优先
/// </summary>
public class SchdHRRF : ProcessSchd
{
public override SimulationResult Simulate()
{
var result = new SimulationResult() { tasks = origin_tasks.ToList() };
result.cpu_clips = SchdImplHelper.GetSimuResultDirectV1(
from x in origin_tasks
orderby x.StartTime
select new SchdRestModel
{
task = x,
rest = x.ExecuteTime,
},
true,
(a, i) =>
from y in
(from x in a
where x.task.StartTime <= i
select new SchdRestModel
{
task = x.task,
rest = x.rest,
temp = ((double)i - (double)x.task.StartTime) / (double)x.task.ExecuteTime
})
orderby y.temp descending
select y
);
return result;
}
}

public class SchdPRIOR : ProcessSchd
{
public override SimulationResult Simulate()
{
var result = new SimulationResult() { tasks = origin_tasks.ToList() };
result.cpu_clips = SchdImplHelper.GetSimuResultDirectV1(
from x in origin_tasks
orderby x.StartTime
select new SchdRestModel
{
task = x,
rest = x.ExecuteTime,
},
false,
(a, i) =>
(from x in a
where x.task.StartTime <= i
orderby x.task.Priority
select x)
);
return result;
}
}

public class SchdRR : ProcessSchd
{
public override SimulationResult Simulate()
{
var result = new SimulationResult() { tasks = origin_tasks.ToList() };
result.cpu_clips = SchdImplHelper.GetSimuResultDirectV2(
from x in origin_tasks
select new SchdRestModel
{
task = x,
rest = x.ExecuteTime,
});
return result;
}
}

运行结果

参见上一篇《五种进程调度的算法实现（二）》结尾处的测试图。