CloudSim 的详解与调度扩展实现

CloudSim 有什么？

对各种组件进行模拟

（1）云数据中心（Datacenter）（2）物理机（Host）（3）虚拟机（VM）（4）服务代理商（DatacenterBroker）（5）任务单元（Cloudlet）（6）云信息服务（CIS）

对各种行为进行模拟

（1）创建VM( VM_CREATE ) （2）删除VM的数据( VM_DATA_DEL ) （3）迁移VM(VM_MIGRATE ) （4）任务提交( CLOUDLET_SUMIT ) （5）任务取消( CLOUDLET_CANCEL )

资源分配进行模拟

（1）虚拟机的主机分配( VmAllocationPolicy ) （2）带宽分配( BwProvisioner ) （3）内存资源分配( RamProvisioner ) （4）总线时间分配( PeProvisioner )

继承这些类可以实现自己的分配策略

组件类

实体 SimEntity

public abstract class SimEntity｛    
    private String name;
    private int id;
    private SimEvent evbuf;
    private int state;
    ...
  public abstract void processEvent(SimEvent ev);
    ...
}

Datacenter 模拟

public class Datacenter extends SimEntity {
private DatacenterCharacteristics characteristics;
private String regionalCisName;
private VmAllocationPolicy vmAllocationPolicy;
private List<? extends Vm> vmList;
@Override
public void processEvent(SimEvent ev) {
.....
}
｝

DatacenterCharacteristics 模拟

public class DatacenterCharacteristics {
private int id;
private String architecture;
private String os;
private List<? extends Host> hostList;
private double costPerSecond;
private String vmm;
private double costPerMem;
private double costPerStorage;
private double costPerBw;
......
｝

Host 对主机的模拟

public class Host {
private int id;
private long storage;
private List<? extends Pe> peList;
private RamProvisioner ramProvisioner;
private BwProvisioner bwProvisioner;
private VmScheduler vmScheduler;
private List<? extends Vm> vmList;
private List<? extends Pe> peList;
public boolean vmCreate(Vm vm) {
  getVmList().add(vm);
  vm.setHost(this);
  return true;
}
｝

CIS 注册机的模拟

public class CloudInformationService extends SimEntity {
private final List<Integer> resList;
private final List<Integer> arList;
@Override
public void processEvent(SimEvent ev) {
  int id = -1;  // requester id
  switch ( ev.getTag() ) {  
   case CloudSimTags.REGISTER_RESOURCE:
      resList.add( (Integer) );break;
   case CloudSimTags.REGISTER_RESOURCE_AR:
      resList.add( (Integer) ev.getData() );
      arList.add( (Integer) ev.getData() ); break;
   case CloudSimTags.RESOURCE_LIST:
      id = ( (Integer) ev.getData() ).intValue();
      super.send(id, 0L, ev.getTag(), resList); break; 
}
}

Broker

屏蔽了云数据中心的内部操作如虚拟机的创建、管理任务单元在虚拟机上的分配用户只需要提交自己的服务请求即可它定义了一组操作，用于和用户与数据中心的交互

event 事件

private final double time; 
private double endWaitingTime; 
private int entSrc; 
private int entDst; 
private final int tag; 
private final Object data;

对云行为进行模拟event,

用户在编程接口向broker提交了创建vm的请求，就会触发broker的一个方法 protected void createVmsInDatacenter(int datacenterId){ ... sendNow(datacenterId, CloudSimTags.VM_CREATE_ACK, vm); ... }

public void processEvent(SimEvent ev) {
....
switch (ev.getTag()) {
...
case CloudSimTags.VM_CREATE_ACK:
        processVmCreate(ev, true);
        break;
...
}
}

对分配策略的模拟

处理单元分配( VmAllocationPolicy )
带宽分配( BwProvisioner )
内存资源分配( RamProvisioner )
总线时间分配( PeProvisioner )

public abstract boolean allocateHostForVm(Vm vm);

这个策略寻找能满足 Vm 需求的Host，然后把Vm创建到这个Host上。

自带的策略分析VmAllocationPolicySimple
public boolean allocateHostForVm(Vm vm) {
...
moreFree = Integer.MIN_VALUE;
for (int i=0; i < freePesTmp.size(); i++) {
if (freePesTmp.get(i) > moreFree) {
moreFree = freePesTmp.get(i);
idx = i;
}
}

Host host = getHostList().get(idx);
result = host.vmCreate(vm);
...

用户自行开发的调度算法可在 DataCenterBroker 的方法中实现，从而实现调度算法的模拟。

CloudSim 仿真步骤

初始化CloudSim 库

CloudSim.init(num_user, calendar, trace_flag);

创建数据中心，在CloudSim平台中，一个数据中心由一个或者多个Machine组成，一个Machine 是由一个或多个 PEs 或 CPUs 组成。

Datacenter datacenter0 = createDatacenter("Datacenter_0");

创建代理 Broker

DatacenterBroker broker = createBroker();
int int int int brokerId = broker.getId();

创建虚拟机

vmlist = new new new new ArrayList<Vm>();
//VM 描述参数
int int int vmid = 0;
int int int int mips = 250;
long long long long size = 10000;
int int int int ram = 512;
long long long long bw = 1000;
int int int int pesNumber = 1;
String vmm = "Xen";
//创建时为虚拟机指定 Broker
Vm vm1 = new new new new Vm(vmid, brokerId, mips, pesNumber, ram, bw, size,
vmm, new new new new CloudletSchedulerTimeShared());
//将虚拟机加入虚拟机列表
vmlist.add(vm1);
//向相应代理 Broker 提交虚拟机列表
broker.submitVmList(vmlist);

创建云任务

cloudletList = new new new new ArrayList<Cloudlet>();
//创建时指定任务的用户 ID,BrokerID

//Cloudlet 描述参数
int int int int id = 0;
pesNumber=1;
long long long long length = 250000;
long long long long fileSize = 300;
long long long long outputSize = 300;
UtilizationModel utilizationModel =new new new new
UtilizationModelFull();
Cloudlet cloudlet1 = new new new new Cloudlet(id, length, pesNumber,
fileSize, outputSize, utilizationModel, utilizationModel,
utilizationModel);
cloudlet1.setUserId(brokerId); ……
//将任务加入任务列表
cloudletList.add(cloudlet1); ……
//向代理Broker提交任务列表
broker.submitCloudletList(cloudletList);

启动仿真

CloudSim.startSimulation();

7 输出结果

List<Cloudlet> newList = broker.getCloudletReceivedList();
CloudSim.stopSimulation();
printCloudletList(newList);
datacenter0.printDebts();

默认的调度策略

默认的调度策略有两个：

独占的调度策略：云任务或者虚拟机要求处理单元独自占用, 如果比处理单元多的任务将会进入等待队列，直到资源可用。
时间分片策略：处理单元共享的方式创建方法，在相关对象的构造函数期间传递新类

虚拟机分配策略在这个类中：

在数据中心中主机提供给一个虚拟机是一个简单的策略，即运行最少虚拟机的主机接收下一个虚拟机。这个行为定义在VMAllocationPolicySimple类中。

DatacenterBroker—修改虚拟机提供请求被提交到数据中心的方式和云任务被提交和被分配给虚拟机的方式。

2） VmAllocationPolicy—你需要去扩展这个抽象类去实现你自己的算法，为了确定哪一个主机分配给一个新的虚拟机。你也可以实现一个动态虚拟机再分配算法通过实现optimizeAllocation方法，它每一次构件时被调用和在这个数据中心的当前虚拟机所有集被传送。

3） VmScheduler—在一个单独主机上实现资源分配给虚拟机算法。

4） CloudletScheduler—在一个单独的虚拟机实现调度云任务的算法。

5） PowerVmAllocationPolicyMigrationAbstract—一个模板类为了实现功率监控动态虚拟机整合算法，用于虚拟机在线迁移到动态再分配虚拟机在每次构件时。重写的主要方法是optimizeAllocation。

CloudSim 里面任务的执行时间等于任务的指令长度（MI）除以运行该任务的虚拟机的执行速度（MIPS）, 即 T = MI/ MIPS

a、如果一个虚拟机上同时运行多个任务，不论使用空间共享还是时间共享，这些任务的执行时间是一定的。（任务的总指令长度和虚拟机的执行速度是一定的）。 b、如果一个任务在某个虚拟机上执行的时间最短，那么它在其他虚拟机上的执行时间也是最短的。 c、如果一个虚拟机的执行速度最快，那么它不论执行哪个任务都是最快的。

任务到虚拟机的分配策略

顺序分配策略

在DatacenterBroker类中实现方法 bindCloudletsToVmsSimples(); 用于把一组任务按顺序分配给一组虚拟机，当所有的虚拟机都有运行任务后，再从第一个虚拟机从头分配任务。

贪心策略

在DatacenterBroker类中实现bindCloudletsToVmsTimeAwared(); 定义一个矩阵 time[i][j],表示任务 i 在虚拟机 j 上所需的执行时间。在初始化矩阵 time 前,首先将任务按 MI 的大小降序排序,将虚拟机按 MIPS 的大小升序排列。从矩阵中行号为 0 的任务开始,每次都尝试分配给最后一列对应的虚拟机, 如果该选择相对于其他选择是最优的,就完成分配,否则将任务分配给使当前结果最优的虚拟机。同时,如果有多种分配方法都能使当前结果最优,则将任务分配给运行任务最少的虚拟机。

// 顺序分配

    public void bindCloudletsToVmsSimple(){
        int vmNum = vmList.size();
        int cloudletNum = cloudletList.size();
        int idx = 0;
        for (int i=0;i<cloudletNum;i++){
            cloudletList.get(i).setVmId(vmList.get(idx).getId());
            idx = (idx+1)%vmNum;
        }
    }

// 贪心分配

public void bindCloudletsToVmsTimeAwared(){
        int cloudletNum=cloudletList.size();
        int vmNum=vmList.size();
        //time[i][j] 表示任务i在虚拟机j上的执行时间
        double[][] time=new double[cloudletNum][vmNum];
        //cloudletList按MI降序排列, vm按MIPS升序排列
        Collections. sort (cloudletList, new CloudletComparator());
        Collections. sort (vmList,new VmComparator());
        //////////For test//////////////////////////////////
        System. out .println("///////////For test///////////////");
        for(int i=0;i<cloudletNum;i++){
            System. out .print(cloudletList.get(i).getCloudletId()+":"+cloudletList.get
                    (i).getCloudletLength()+" ");
        }
        System. out .println();
        for (int i=0;i< vmNum;i++){
            System. out .print(vmList.get(i).getId()+":"+vmList.get(i).getMips()+" ");
        }
        System. out .println();
        System. out .println("//////////////////////////////////");
        //////////////////////////////////////////////////////////////////////
       for (int i=0;i<cloudletNum;i++){
         for(int j=0;j<vmNum;j++){
            time[i][j]= (double)cloudletList.get(i).getCloudletLength()/vmList.get(j).getMips();
            System. out .print("time["+i+"]["+j+"]="+time[i][j]);
        }
        System. out .println();
      //For test
    }

    double[] vmLoad=new double[vmNum];//在某个虚拟机上任务的总执行时间
    int[] vmTasks=new int[vmNum]; //在某个Vm上运行的任务数量
    double minLoad=0;//记录当前任务分配方式的最优值
    int idx=0;//记录当前任务最优分配方式对应的虚拟机列号
    //第一个cloudlet分配给最快的vm
    vmLoad[vmNum-1]=time[0][vmNum-1];
    vmTasks[vmNum-1]=1;
    cloudletList.get(0).setVmId(vmList.get(vmNum-1).getId());
    for(int i=1;i<cloudletNum;i++){
         minLoad=vmLoad[vmNum-1]+time[i][vmNum-1];
         idx=vmNum-1;
        for(int j=vmNum-2;j>=0;j--){
            //如果当前虚拟机未分配任务,则比较完当前任务分配给该虚拟机是否最优
            if(vmLoad[j]==0){
                if(minLoad>=time[i][j]) {
                    idx = j;
                }
                break;
            }
            if(minLoad>vmLoad[j]+time[i][j]){
                minLoad=vmLoad[j]+time[i][j];
                idx=j;
            }
            //简单的负载均衡
            else if(minLoad==vmLoad[j]+time[i][j]&&vmTasks[j]<vmTasks[idx]) {
                idx = j;
            }
        }
        vmLoad[idx]+=time[i][idx];
        vmTasks[idx]++;
        cloudletList.get(i).setVmId(vmList.get(idx).getId());
        System. out .print(i+"th "+"vmLoad["+idx+"]="+vmLoad[idx]+"minLoad="+minLoad);
        System. out .println();
    }
}
        //Cloudlet根据MI降序排列
        private class CloudletComparator implements Comparator<Cloudlet>{
            @Override
            public int compare(Cloudlet cl1, Cloudlet cl2){
                return (int)(cl2.getCloudletLength()-cl1.getCloudletLength());
            }
        }
        //Vm根据MIPS升序排列
        private class VmComparator implements Comparator<Vm>{
            @Override
            public int compare(Vm vm1, Vm vm2){
                return (int)(vm1.getMips()-vm2.getMips());
            }
        }

如果只是提交了任务列表和Vm列表，并未将任务分配给指定的虚拟机，那么Datacenterbroker将会，检测当前有未使用的虚拟机，检测有未分配的任务，使用顺序的轮转法进行分配

具体可以看在Broker中源码：

protected void submitCloudlets() {
        int vmIndex = 0;
        List<Cloudlet> successfullySubmitted = new ArrayList<Cloudlet>();
        for (Cloudlet cloudlet : getCloudletList()) {
            Vm vm;
            // if user didn't bind this cloudlet and it has not been executed yet
            if (cloudlet.getVmId() == -1) {
                vm = getVmsCreatedList().get(vmIndex);
            } else { // submit to the specific vm
                vm = VmList.getById(getVmsCreatedList(), cloudlet.getVmId());
                if (vm == null) { // vm was not created
                    if(!Log.isDisabled()) {                 
                        Log.printConcatLine(CloudSim.clock(), ": ", getName(), ": Postponing execution of cloudlet ",
                            cloudlet.getCloudletId(), ": bount VM not available");
                    }
                    continue;
                }
            }

            if (!Log.isDisabled()) {
                Log.printConcatLine(CloudSim.clock(), ": ", getName(), ": Sending cloudlet ",
                    cloudlet.getCloudletId(), " to VM #", vm.getId());
            }
            
            cloudlet.setVmId(vm.getId());
            sendNow(getVmsToDatacentersMap().get(vm.getId()), CloudSimTags.CLOUDLET_SUBMIT, cloudlet);
            cloudletsSubmitted++;
            vmIndex = (vmIndex + 1) % getVmsCreatedList().size();
            getCloudletSubmittedList().add(cloudlet);
            successfullySubmitted.add(cloudlet);
        }

        // remove submitted cloudlets from waiting list
        getCloudletList().removeAll(successfullySubmitted);
    }