首先理解云计算里，资源调度的含义：
看了很多云计算资源调度和任务调度方面的论文，发现很多情况下这两者的意义是相同的，不知道这两者是同一件事的不同表述还是我没分清吧，任务调度或者资源调度大概就是讲这样一件事情：
用户有n个计算任务(Task)，{t1,t2,t3,...tm}，将这n个任务分配到m个资源(其实就是指虚拟机，Virtual Machine)上，用这m个资源来计算这n个任务(注意，一般n>m，且很多时候n>>m)，直到所有任务都计算完成。如何分配使得这n个任务的总的计算时间最少？这里，总的计算时间是指，最后一个计算完成的任务的完成时刻，而不是每个任务的计算时间求和。
关于这个问题的准确的描述，引用王登科 李 忠《基于粒子群优化与蚁群优化的云计算任务调度算法》的描述：
举个例子：
假设某云计算系统的一台主机上运行了3个虚拟机{VM0,VM1,VM2}，它们的计算能力(即单位时间内能够执行的指令数量,CloudSim里用mips来衡量)分别是{3000,1000,500}.
某用户有5个计算任务{t0,t1,t2,t3,t4},任务大小(就是要执行的指令数量，CloudSim里用length来表示)分别是{4000,2000,2500,10000,500}，提交到cloudsim系统中进行模拟运算。
根据cloudsim默认的调度策略，产生的调度结果是：VM0={t0,t3},VM1={t1,t4},VM2={t2}
由于VM0,VM1,VM2并行执行，互不影响，因此
VM0上的执行时间为：(t0+t3)/VM0 mips=(4000+10000)/3000=4.667,
VM1上的执行时间为：(t1+t4)/VM1 mips=(2000+500)/1000=2.5,
VM2上的执行时间为：t2/VM2 mips=2500/500=5。
因此这种调度方案的总的运行时间为max{4.667,2.5,5}=5。
其中，这种调度方案，可用一个二维表来表示：
这个表跟上面的那个X表行和列对调了一下，但意思一样，注意观察每一行都只有一个1，表示每个任务只能分配给一个资源(虚拟机)进行计算，但1个资源(虚拟机)可能计算不止一个任务。
如果运用遗传算法或其他进化算法，需要对每个解(对应这里的每一种调度方案)，计算它的适应度值(这里的适应度函数就是每种调度方案对应的任务完成时间)，选择适应度值最好的作为最优，进行下一次迭代。
如何把一种调度方案表示为一个解，如何计算解的适应度值？可以参考：非常好的理解遗传算法的例子
这里，可以把每一行的二进制数化成一个十进制整数，每个数取值只能取{20,21,22,...,2m-1}中的任意一个，共n个任务，即有n个这样的数，这就是遗传算法当中的所谓编码，即用一种方式来把调度方案表示成解（上面的调度方案可表示为42142，每一位数表示资源的分配结果)。
或者用资源的编号组合来表示调度方案：n个任务，每个任务从[0,m-1]之间的整数任取一个，那么一个调度方案就是一个1*n维的向量，如上例的调度方案可表示为 [0,1,2,0,1]
而把解转化成调度方案就是所谓解码。
如何把把自己的算法，如遗传算法运用到Cloudsim中去？最简单的办法是调用DatacenterBroker的 bindCloudletToVM(int cloudletId, int vmId)，通过遗传算法的计算结果用代码动态调用该方法，将任务与资源进行绑定，这种绑定就是任务的调度的体现。
如何理解遗传算法本身，请参考：遗传算法(Genetic Algorithm)
说到这，我有点疑问，按照上面的调度表格，每个任务必须要为它分配一个资源，且只能分配一个资源，那调度方案的总个数其实是可以穷举的，因为n个任务，m个资源，每个任务都有m种选择，一共就是mn种调度方案。所以最佳调度方案其实是很容易穷举算出来的，为什么还要用遗传算法之类的进化算法来算呢？可能是当n足够大之后，mn这个值太大，调度方案太多，导致穷举太耗时，才需要这些调度算法吧。
Cloudsim模拟的实例代码：
public static void RunSimulation(int []taskLength,int taskNum)
{
System.out.println("Starting to run simulations..."); try
{
int num_user = 1; // number of cloud users
Calendar calendar = Calendar.getInstance();
boolean trace_flag = false; CloudSim.init(num_user, calendar, trace_flag); //下面创建的datacenter是用来运行任务的物理硬件，是必需的，否则不能运行。它被创建之后看似没有调用，好像没啥用，其实DataCenter构造函数把它与CloudSim类进行了绑定，所以能够发挥作用
@SuppressWarnings("unused")
Datacenter datacenter0 = createDatacenter("Datacenter_0"); // #3 step: Create Broker
DatacenterBroker broker = createBroker();
int brokerId = broker.getId();
// #4 step: Create one virtual machine
vmlist = new ArrayList<Vm>(); // VM description
long size = 10000; // image size (MB)
int ram = 512; // vm memory (MB)
long bw = 1000;
int pesNumber = 1; // number of cpus
String vmm = "Xen"; // VMM name double mips=5000;//mips是虚拟机的cpu处理速度，cloudlet的length/虚拟机mips=任务执行所需时间
//所有虚拟机的mips之和不能超过datacenter中定义的主机的物理cpu的mips之和，而虚拟cpu的mips的最大值也不能超过物理cpu的最大值，否则虚拟机将创建失败。
Vm vm1 = new Vm(0, brokerId, mips, pesNumber, ram, bw, size,
vmm, new CloudletSchedulerSpaceShared());
mips=2500;
Vm vm2 = new Vm(1, brokerId, mips, pesNumber, ram, bw, size,
vmm,new CloudletSchedulerTimeShared());
mips=2500;
Vm vm3 = new Vm(2, brokerId, mips, pesNumber, ram, bw, size,
vmm,new CloudletSchedulerTimeShared());
mips=1500;
Vm vm4 = new Vm(3, brokerId, mips, pesNumber, ram, bw, size,
vmm, new CloudletSchedulerSpaceShared());
mips=1000;
Vm vm5 = new Vm(4, brokerId, mips, pesNumber, ram, bw, size,
vmm, new CloudletSchedulerSpaceShared()); // add the VMs to the vmList
vmlist.add(vm1);
vmlist.add(vm2);
vmlist.add(vm3);
vmlist.add(vm4);
vmlist.add(vm5); // submit vm list to the broker
broker.submitVmList(vmlist); // #5 step: Create cloudlets
cloudletList = new ArrayList<Cloudlet>(); // Cloudlet properties
int id = 0;
pesNumber = 1; long fileSize = 250;
long outputSize = 10000000;
UtilizationModel utilizationModel = new UtilizationModelFull(); for(int i=0;i<taskNum;i++)
{
//Cloudlet构造函数的一个参数为任务id，第二个参数为任务长度(指令数量)
Cloudlet task = new Cloudlet(i, taskLength[i], pesNumber, fileSize,
outputSize, utilizationModel, utilizationModel,
utilizationModel);
task.setUserId(brokerId); cloudletList.add(task);
} broker.submitCloudletList(cloudletList); for(int i=0;i<taskNum;i++)
{
//下面的两行代码用于把任务绑定到指定的虚拟机上，两行代码效果是一样的
//如果需要用自己实现的算法来进行资源调度，则可以在算法中动态调用DataCenterBroker.bindCloudletToVm()方法或者Cloudlet.setVmId()方法
//broker.bindCloudletToVm(cloudletList.get(i).getCloudletId(),vm1.getId());
cloudletList.get(i).setVmId(vm1.getId());
} bindAllTaskToSameVM(cloudletList,vm1.getId()); CloudSim.startSimulation(); // Final step: Print results when simulation is over
List<Cloudlet> newList = broker.getCloudletReceivedList(); CloudSim.stopSimulation(); for(Vm vm:vmlist)
{
System.out.println(String.format("vm id= %s ,mips = %s ",vm.getId(),vm.getMips()));
} printCloudletList(newList);
System.out.println("CloudSim simulation is finished!");
}
catch (Exception e)
{
e.printStackTrace();
System.out.println("The simulation has been terminated due to an unexpected error");
}
} private static Datacenter createDatacenter(String name)
{
List<Host> hostList = new ArrayList<Host>();
List<Pe> peList = new ArrayList<Pe>(); //创建五个cpu,mips为cpu的处理速度
int mips = 5000;
peList.add(new Pe(0, new PeProvisionerSimple(mips))); // need to store Pe id and MIPS Rating mips = 2500;
peList.add(new Pe(1, new PeProvisionerSimple(mips))); // need to store mips = 2500;
peList.add(new Pe(2, new PeProvisionerSimple(mips))); // need to store mips = 1500;
peList.add(new Pe(3, new PeProvisionerSimple(mips))); // need to store mips = 1000;
peList.add(new Pe(4, new PeProvisionerSimple(mips))); // need to store int hostId = 0;
int ram = 4096; // host memory (MB)
long storage = 10000000; // host storage
int bw = 10000; hostList.add(new Host(hostId, new RamProvisionerSimple(ram),
new BwProvisionerSimple(bw), storage, peList,
new VmSchedulerTimeShared(peList)));
String arch = "x86"; // system architecture
String os = "Linux"; // operating system
String vmm = "Xen";
double time_zone = 10.0; // time zone this resource located
double cost = 3.0; // the cost of using processing in this resource
double costPerMem = 0.05; // the cost of using memory in this resource
double costPerStorage = 0.001; // the cost of using storage in this
// resource
double costPerBw = 0.001; // the cost of using bw in this resource //we are not adding SAN devices by now
LinkedList<Storage> storageList = new LinkedList<Storage>(); DatacenterCharacteristics characteristics = new DatacenterCharacteristics(
arch, os, vmm, hostList, time_zone, cost, costPerMem,
costPerStorage, costPerBw); // 6. Finally, we need to create a PowerDatacenter object.
Datacenter datacenter = null;
try
{
datacenter = new Datacenter(name, characteristics,
new VmAllocationPolicySimple(hostList), storageList, 0);
} catch (Exception e)
{
e.printStackTrace();
} return datacenter;
} private static DatacenterBroker createBroker()
{ DatacenterBroker broker = null;
try
{
broker = new DatacenterBroker("Broker");
} catch (Exception e)
{
e.printStackTrace();
return null;
}
return broker;
} private static void printCloudletList(List<Cloudlet> list)
{
int size = list.size();
Cloudlet cloudlet; String indent = " ";
System.out.println();
System.out.println("========== OUTPUT ==========");
System.out.println("Cloudlet ID" + indent + "STATUS" + indent
+ "Data center ID" + indent + "VM ID" + indent +"CloudletLength"+indent+ "Time"
+ indent + "Start Time" + indent + "Finish Time"); DecimalFormat dft = new DecimalFormat("###.##");
for (int i = 0; i < size; i++)
{
cloudlet = list.get(i);
Log.print(indent + cloudlet.getCloudletId() + indent + indent); if (cloudlet.getStatus()== Cloudlet.SUCCESS)
{
Log.print("SUCCESS"); System.out.println(indent +indent + indent + cloudlet.getResourceId()
+ indent + indent + indent + cloudlet.getVmId()
+ indent + indent + cloudlet.getCloudletLength()
+ indent + indent+ indent + indent
+ dft.format(cloudlet.getActualCPUTime()) + indent
+ indent + dft.format(cloudlet.getExecStartTime())
+ indent + indent
+ dft.format(cloudlet.getFinishTime()));
}
}
}
本文链接：http://www.cnblogs.com/aaronhoo/p/6218024.html
参考资料：
《基于粒子群优化与蚁群优化的云计算任务调度算法》王登科 李 忠
硕士论文《基于云计算环境下资源调度算法研究》 邬海艳