Prepartition算法研读与算例实现
目录
0.参考文献：
1.核心概念与问题理解
-
Prepartition算法的核心是将VM的分配过程建模成一种修改间隔的调度问题，并假设任务的处理时间长度是固定的。在容量共享的间隔调度中，（即在调度期间各个VM可以共享PM的capacity,只要他们的总和不超过PM的负载或者规定的下限值）的目标是使各个VM能更均衡地分配到每个PM中。
-
Makespan是此文中测试算法负载均衡的重要指标，他原本表示某个PM上的最大总负载（简单处理为处理时间），即所有任务完成处理后，在处理分配到该物理机上所有任务占用的总时间。在寻找最小化makespan的分配过程中，离线调度一般为NP-Hard问题。但由于共享容量间隔调度的引入，文章将Makespan重新定义为了Capacity_makespan。（makespan在文中还有最高平均利用率以及最长处理时间的定义?）
-
Capacity_makespan：每一个请求 v m j vm_{j} vmj的所需资源 d j d_j dj与在物理机 p m i pm_i pmi上的持续时间 t j t_j tj的乘积之和。
-
因此，负载平衡的目标就变为了最小化任何PM上的最大负载。
-
考虑PM和VM生命周期等问题，有提出反应式迁移算法（后迁移），它更多地采用启发式的算法实现迁移列表的实现与虚拟机的迁移。但很难达到预计效果。在此基础上提出预分割的主动VM迁移调度算法。
-
对于一组虚拟机任务，考虑 m m m台物理机，OPT表示 J J J个虚拟机调度完成后的最优解：
-
预分割算法:调度开始之后，算法首先通过上述公式算分割值，再结合分割数的值k (如k=4)，获得每次分割后的capacity_ makespan的长度（表明虚拟机任务可以在物理机.上持续运行的capacity_ makespan长度)， 在预分割算法中,如果虚拟机任务的CM值大于上述值,虚拟机任务则会被等分成多个 P 0 / k P_0/k P0/k的子任务(分割后的最后一个子任务capacity_ makespan长度可能小于该值)，分割操作完成后，依次寻找capacity_ makespan值最小且具有足够剩余资源的物理机，并将任务分配到该物理机上，直到所有的任务都完成分配。最后计算分割次数和其他负载均衡指标的数值。
2.算例解释与核心算法模块实现
2.1.预分割模块之capacity_ makespan的长度 P 0 / k P_0/k P0/k计算
/**
* Capacity_makespan core methods. Partitioning the requests into parts and create a new VM queue with new capacity_makespan value. The start time and end time may be different from the previous ones.
* @param p_vmQueue
* @param pmQueueOneSize
* @return
*/
private ArrayList<VirtualMachine> processCMP(ArrayList<VirtualMachine> p_vmQueue, int m) {
//CM值
int capacity_makespan = 0;
//最大CM
int maxCapacity_makespan = 0;
//平均CM
int averageCapacity_makespan = 0;
int partitionCapacity_makespan = 0;
VirtualMachine vm2;
//The new vm queue after partition
ArrayList<VirtualMachine> cmp_vmQueue = new ArrayList<VirtualMachine>();
/*
* Calculate 0.25 * max(L1, L2)；计算分割之后的CM长度
*/
for (int i = 0; i < p_vmQueue.size(); i++) {
vm2 = p_vmQueue.get(i);
//计算单个VM的最大CM值
capacity_makespan = (int) ((vm2.getEndTime() - vm2.getStartTime()) * vm2.getCpuTotal());
if (capacity_makespan > maxCapacity_makespan) {
maxCapacity_makespan = capacity_makespan;
}
averageCapacity_makespan += capacity_makespan;
}
//根据pm个数，计算平均的cm
averageCapacity_makespan /= m;
//计算分割之后的CM值，k值选4;
int k = 4;
partitionCapacity_makespan = maxCapacity_makespan > averageCapacity_makespan ? maxCapacity_makespan : averageCapacity_makespan;
//定义vm可以在pm上连续运行的最大时间长度
partitionCapacity_makespan =(int) Math.ceil(partitionCapacity_makespan*1.0 / k );
DataCenterFactory.print.println("CMP(p0/k)=" + partitionCapacity_makespan);
/*
* Recombine the requests;重新组合请求
*/
for (int i = 0; i < p_vmQueue.size(); i++) {
vm2 = p_vmQueue.get(i);
regenVM(vm2, partitionCapacity_makespan, cmp_vmQueue);
}
//DataCenterFactory.print.println("Partition Times:" + (cmp_vmQueue.size() - p_vmQueue.size()));
//输出新vm结果
System.out.println("新分区结果为：");
for( int i =0 ; i<cmp_vmQueue.size() ; i++ ){
System.out.println(cmp_vmQueue.get(i).getVmNo()+" "+ cmp_vmQueue.get(i).getStartTime()+" "+cmp_vmQueue.get(i).getEndTime()+ " " + cmp_vmQueue.get(i).getVmType());
}
System.out.println("——————————————");
return cmp_vmQueue;
}
2.2 分割后重新分配算法
/**
* Method to generate new VM queue, if a VM capacity_makespan is less than the partitionCapacity_makespan, add the VM to new queue. If not, divide the vm into more than one vms and put them to the new queue.
*/
public void regenVM(VirtualMachine vm2, int partitionCapacity_makespan, ArrayList<VirtualMachine> cmp_vmQueue) {
int capacity_makespan = 0;
VirtualMachine vm3, vm4;
int duration;
int durNum;
//double duration;
capacity_makespan = (int) ((vm2.getEndTime() - vm2.getStartTime()) * vm2.getCpuTotal());
if (capacity_makespan <= partitionCapacity_makespan) {
vm3 = new VirtualMachine(
vmID++, vm2.getStartTime(), vm2.getEndTime(), vm2.getVmType());
cmp_vmQueue.add(vm3);
} else {
//如果CM > p0/k,那么将其划分为若干个p0/k的子区间
durNum =(int) Math.ceil(capacity_makespan*1.0 / partitionCapacity_makespan);
duration = (int) Math.ceil(capacity_makespan*1.0 / vm2.getCpuTotal() / durNum);
for(int i =0 ;i < durNum ; i++ ){
if(i == 0){
vm3 = new VirtualMachine(vmID++ , vm2.getStartTime()+i*duration,vm2.getStartTime()+(i+1)*duration,vm2.getVmType());
}
else if(i == durNum -1){
vm3 = new VirtualMachine(vmID++ , vm2.getStartTime()+i*duration+1,vm2.getEndTime(),vm2.getVmType());
}
else{
vm3 = new VirtualMachine(vmID++ , vm2.getStartTime()+i*duration+1,vm2.getStartTime()+(i+1)*duration,vm2.getVmType());
}
cmp_vmQueue.add(vm3);
}
//算法问题
// duration = (int) ((capacity_makespan - partitionCapacity_makespan) / vm2.getCpuTotal());
// //duration = Math.ceil((capacity_makespan - partitionCapacity_makespan) / vm2.getCpuTotal());
// vm3 = new VirtualMachine(vmID++, vm2.getStartTime(),
// vm2.getStartTime() + duration, vm2.getVmType());
// cmp_vmQueue.add(vm3);
// vm4 = new VirtualMachine(vmID, vm3.getEndTime() + 1, vm2.getEndTime(), vm2.getVmType());
// //recursive method
// regenVM(vm4, partitionCapacity_makespan, cmp_vmQueue);
}
}
2.3 反应式（后）迁移再分配算法
/**
* Migrate the vms from the PM with highest CM value to PM with lowest CM value
*/
private void reallocateVm(ArrayList<PhysicalMachine> pmQueue){
int size = pmQueue.size();
PhysicalMachine pm1, pm2;
VirtualMachine vm1;
//Collections.sort(pmQueue, new SortByCapacityMakespan());
for (int i = 0 ; i < pmQueue.size(); i++) {
Collections.sort(pmQueue, new SortByCapacityMakespan());
if (pmQueue.get(0).getTotalCapacityMakespan() > threshold) {
pm1 = pmQueue.get(0);
pm2 = pmQueue.get(size - 1);
vm1 = pm1.vms.get(0);
if (checkResourceAvailble(vm1, pm2)) {
pm1.vms.remove(vm1);
updateResource(vm1, pm1, increase);
pm2.vms.add(vm1);
vm1.setPmNo(pm2.getNo());
updateResource(vm1, pm2, decrease);
} else {
DataCenterFactory.print.println("Migration Failed!");
}
} else {
DataCenterFactory.print.println("Migartion Finished......");
break;
}
}
3.迭代修复和更新FlexFloud（功能持续完善中）
- 见个人Github项目地址：https://github.com/Cheny1m/FlexCloud
4.利用FlexFloud工具与LLNL DATA数据进行论文复现（部分）
5.本周所遇到的困难与问题总结
- 主要是刚接触云资源负载均衡与节能调度算法方面的知识，有许多系统知识与文献需要时间补充才能更好地理解算法优化的动机与理论支撑。
- 关于文献中Makespan指标的理解有歧义（双重定义，且开始结果一直存在问题）；对文章中提到的Prepartition与MIG资源分配过程与算法实现花了较多思考时间。复现文章的结果还不够理想。
- 对于FlexCloud工具的扩展。由于部分指标索引定义不同，包括请求方式变动带来的工作量增加。
6.下周学习和工作计划
- 适当完善算法与指标计算，修正部分方法问题，使复现结果更加靠近论文结果。同时进一步体会不同的调度算法的理论差异与实现过程及方法。
- 拓展FlexCloud数据中心的界面修复与产生数据的维度（包括数据位置不同等方面的抽象），解耦部分模块提升程序运行速度与灵活性。
- 阅读负载均衡的相关文献，了解更多相关研究同时兼顾节能调度的阅读与融合。
1026
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
