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

完整的GA算法的工程实现，包括与轮询(RR)算法效果对比：

完整项目代码地址（导入到eclipse中即可运行）： GA-cloudsim.zip

遗传算法GA的核心代码实现：

最核心：

private static ArrayList<int[]> GA(ArrayList<int[]> pop,int gmax,double crossoverProb,double mutationRate)
    {
        HashMap<Integer,double[]> segmentForEach=calcSelectionProbs(pop);
        ArrayList<int[]> children=new ArrayList<int[]>();
        ArrayList<int[]> tempParents=new ArrayList<int[]>();
        while(children.size()<pop.size())
        {    
            //selection phase:select two parents each time.
            for(int i=0;i<2;i++)
            {
                double prob = new Random().nextDouble();
                for (int j = 0; j < pop.size(); j++)
                {
                    if (isBetween(prob, segmentForEach.get(j)))
                    {
                        tempParents.add(pop.get(j));
                        break;
                    }
                }
            }
            //cross-over phase.
            int[] p1,p2,p1temp,p2temp;
            p1= tempParents.get(tempParents.size() - 2).clone();
            p1temp= tempParents.get(tempParents.size() - 2).clone();
            p2 = tempParents.get(tempParents.size() -1).clone();
            p2temp = tempParents.get(tempParents.size() -1).clone();
            if(new Random().nextDouble()<crossoverProb)
            {
                int crossPosition = new Random().nextInt(cloudletList.size() - 1);
                //cross-over operation
                for (int i = crossPosition + 1; i < cloudletList.size(); i++)
                {
                    int temp = p1temp[i];
                    p1temp[i] = p2temp[i];
                    p2temp[i] = temp;
                }
            }
            //choose the children if they are better,else keep parents in next iteration.
            children.add(getFitness(p1temp) < getFitness(p1) ? p1temp : p1);
            children.add(getFitness(p2temp) < getFitness(p2) ? p2temp : p2);    
            // mutation phase.
            if (new Random().nextDouble() < mutationRate)
            {
                // mutation operations bellow.
                int maxIndex = children.size() - 1;

                for (int i = maxIndex - 1; i <= maxIndex; i++)
                {
                    operateMutation(children.get(i), mutationRate);
                }
            }
        }
        
        gmax--;
        return gmax > 0 ? GA(children, gmax, crossoverProb, mutationRate): children;
    }

完整核心代码：

private static int[] findBestSchedule(ArrayList<int[]> pop)
    {
        double bestFitness=1000000000;
        int bestIndex=0;
        for(int i=0;i<pop.size();i++)
        {
            int []schedule=pop.get(i);
            double fitness=getFitness(schedule);
            if(bestFitness>fitness)
            {
                bestFitness=fitness;
                bestIndex=i;
            }
        }
        return pop.get(bestIndex);
    }
    
    private static int[] getScheduleByGA(int popSize,int gmax,double crossoverProb,double mutationRate)
    {
        ArrayList<int[]> pop=initPopsRandomly(cloudletList.size(),vmList.size(),popSize);
        pop=GA(pop,gmax,crossoverProb,mutationRate);
        return findBestSchedule(pop);
    }
    
    private static ArrayList<int[]> initPopsRandomly(int taskNum,int vmNum,int popsize)
    {
        ArrayList<int[]> schedules=new ArrayList<int[]>();
        for(int i=0;i<popsize;i++)
        {
            //data structure for saving a schedule：array,index of array are cloudlet id,content of array are vm id.
            int[] schedule=new int[taskNum];
            for(int j=0;j<taskNum;j++)
            {
                schedule[j]=new Random().nextInt(vmNum);
            }
            schedules.add(schedule);
        }
        return schedules;
    }
    
    private static double getFitness(int[] schedule)
    {
        double fitness=0;

        HashMap<Integer,ArrayList<Integer>> vmTasks=new HashMap<Integer,ArrayList<Integer>>();
        int size=cloudletList.size();
        
        for(int i=0;i<size;i++)
        {
            if(!vmTasks.keySet().contains(schedule[i]))
            {
                ArrayList<Integer> taskList=new ArrayList<Integer>();
                taskList.add(i);
                vmTasks.put(schedule[i],taskList);
            }
            else
            {
                vmTasks.get(schedule[i]).add(i);
            }
        }

        for(Entry<Integer, ArrayList<Integer>> vmtask:vmTasks.entrySet())
        {
            int length=0;
            for(Integer taskid:vmtask.getValue())
            {
                length+=getCloudletById(taskid).getCloudletLength();
            }
            
            double runtime=length/getVmById(vmtask.getKey()).getMips();
            if (fitness<runtime)
            {
                fitness=runtime;
            }
        }
        
        return fitness;
    }

    private static ArrayList<int[]> GA(ArrayList<int[]> pop,int gmax,double crossoverProb,double mutationRate)
    {
        HashMap<Integer,double[]> segmentForEach=calcSelectionProbs(pop);
        ArrayList<int[]> children=new ArrayList<int[]>();
        ArrayList<int[]> tempParents=new ArrayList<int[]>();
        while(children.size()<pop.size())
        {    
            //selection phase:select two parents each time.
            for(int i=0;i<2;i++)
            {
                double prob = new Random().nextDouble();
                for (int j = 0; j < pop.size(); j++)
                {
                    if (isBetween(prob, segmentForEach.get(j)))
                    {
                        tempParents.add(pop.get(j));
                        break;
                    }
                }
            }
            //cross-over phase.
            int[] p1,p2,p1temp,p2temp;
            p1= tempParents.get(tempParents.size() - 2).clone();
            p1temp= tempParents.get(tempParents.size() - 2).clone();
            p2 = tempParents.get(tempParents.size() -1).clone();
            p2temp = tempParents.get(tempParents.size() -1).clone();
            if(new Random().nextDouble()<crossoverProb)
            {
                int crossPosition = new Random().nextInt(cloudletList.size() - 1);
                //cross-over operation
                for (int i = crossPosition + 1; i < cloudletList.size(); i++)
                {
                    int temp = p1temp[i];
                    p1temp[i] = p2temp[i];
                    p2temp[i] = temp;
                }
            }
            //choose the children if they are better,else keep parents in next iteration.
            children.add(getFitness(p1temp) < getFitness(p1) ? p1temp : p1);
            children.add(getFitness(p2temp) < getFitness(p2) ? p2temp : p2);    
            // mutation phase.
            if (new Random().nextDouble() < mutationRate)
            {
                // mutation operations bellow.
                int maxIndex = children.size() - 1;

                for (int i = maxIndex - 1; i <= maxIndex; i++)
                {
                    operateMutation(children.get(i), mutationRate);
                }
            }
        }
        
        gmax--;
        return gmax > 0 ? GA(children, gmax, crossoverProb, mutationRate): children;
    }
    
    public static void operateMutation(int []child,double mutationRate)
    {
        if(new Random().nextDouble()<mutationRate)
        {
            int mutationIndex=new Random().nextInt(cloudletList.size());
            int newVmId=new Random().nextInt(vmList.size());
            while(child[mutationIndex]==newVmId)
            {
                newVmId=new Random().nextInt(vmList.size());
            }
            
            child[mutationIndex]=newVmId;
        }
    }
    
    private static boolean isBetween(double prob,double[]segment)
    {
        if(segment[0]<=prob&&prob<=segment[1])
            return true;
        return false;    
    }
    
    private static HashMap<Integer,double[]> calcSelectionProbs(ArrayList<int[]> parents)
    {
        int size=parents.size();
        double totalFitness=0;    
        ArrayList<Double> fits=new ArrayList<Double>();
        HashMap<Integer,Double> probs=new HashMap<Integer,Double>();
        
        for(int i=0;i<size;i++)
        {
            double fitness=getFitness(parents.get(i));
            fits.add(fitness);
            totalFitness+=fitness;
        }
        for(int i=0;i<size;i++)
        {
            probs.put(i,fits.get(i)/totalFitness );
        }
        
        return getSegments(probs);
    }
    
    private static HashMap<Integer,double[]> getSegments(HashMap<Integer,Double> probs)
    {
        HashMap<Integer,double[]> probSegments=new HashMap<Integer,double[]>();
        //probSegments保存每个个体的选择概率的起点、终点，以便选择作为交配元素。
        int size=probs.size();
        double start=0;
        double end=0;
        for(int i=0;i<size;i++)
        {
            end=start+probs.get(i);
            double[]segment=new double[2];
            segment[0]=start;
            segment[1]=end;
            probSegments.put(i, segment);
            start=end;
        }
        
        return probSegments;
    }