用遗传算法GA改进CloudSim自带的资源调度策略

首先理解云计算里，资源调度的含义：

看了很多云计算资源调度和任务调度方面的论文，发现很多情况下这两者的意义是相同的，不知道这两者是同一件事的不同表述还是我没分清吧，任务调度或者资源调度大概就是讲这样一件事情：

用户有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个资源(虚拟机)可能计算不止一个任务。

如果运用遗传算法或其他进化算法，需要对每个解(对应这里的每一种调度方案)，计算它的适应度值(这里的适应度函数就是每种调度方案对应的任务完成时间)，选择适应度值最好的作为最优，进行下一次迭代。

如何把一种调度方案表示为一个解，如何计算解的适应度值？可以参考：非常好的理解遗传算法的例子

这里，可以把每一行的二进制数化成一个十进制整数，每个数取值只能取{2⁰,2¹,2²,...,2^m-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种选择，一共就是mⁿ种调度方案。所以最佳调度方案其实是很容易穷举算出来的，为什么还要用遗传算法之类的进化算法来算呢？可能是当n足够大之后，mⁿ这个值太大，调度方案太多，导致穷举太耗时，才需要这些调度算法吧。

链接：基于遗传算法的资源调度策略的代码实现

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

参考资料：

《基于粒子群优化与蚁群优化的云计算任务调度算法》王登科 李 忠

硕士论文《基于云计算环境下资源调度算法研究》 邬海艳

http://blog.csdn.net/b2b160/article/details/4680853/

http://blog.chinaunix.net/uid-27105712-id-3886077.html