source: DCWoRMS/branches/coolemall/src/test/testSOP/algorithms/multicloud/ComparatorRankingMetasched.java @ 1606

package test.testSOP.algorithms.multicloud;

import java.util.Comparator;

import schedframe.resources.computing.ComputingResource;
import schedframe.resources.computing.Node;
import schedframe.scheduling.Scheduler;
import schedframe.scheduling.manager.resources.ManagedComputingResources;
import schedframe.scheduling.manager.tasks.JobRegistry;
import schedframe.scheduling.manager.tasks.JobRegistryImpl;
import test.testSOP.Utility;

//Copie de lowest load first
public class ComparatorRankingMetasched implements Comparator<Scheduler>{
        @Override
        public int compare(Scheduler sched1, Scheduler sched2) {
                ManagedComputingResources c1 = sched1.getCompResources();
                ManagedComputingResources c2 = sched2.getCompResources();
                float mean_load_cpu_c1 = 0;
                float mean_load_mem_c1 = 0;
                float vm_number_c1 = 0;
                float nb=0;
                for (ComputingResource cr : c1) {
                        Node node = (Node)cr;
                        mean_load_cpu_c1 += node.getLoadInterface().getRecentUtilization().getValue();
                        try {
                                mean_load_mem_c1 += ((float)node.getTotalMemory() - (float)node.getFreeMemory()) / (float)node.getTotalMemory();
                        } catch (NoSuchFieldException e) {
                                // TODO Auto-generated catch block
                                e.printStackTrace();
                        }
                        
                        JobRegistry nodeJR = new JobRegistryImpl(node.getFullName());
                        synchronized(nodeJR) {
                                vm_number_c1 += Utility.getAllRunningTasks(nodeJR);
                        }
                        nb++;
                }
                mean_load_cpu_c1 = mean_load_cpu_c1 / nb;
                mean_load_mem_c1 = mean_load_mem_c1 / nb;
                
                float mean_load_cpu_c2 = 0;
                float mean_load_mem_c2 = 0;
                float vm_number_c2 = 0;
                nb=0;
                for (ComputingResource cr : c1) {
                        Node node = (Node)cr;
                        mean_load_cpu_c2 += node.getLoadInterface().getRecentUtilization().getValue();
                        try {
                                mean_load_mem_c2 += ((float)node.getTotalMemory() - (float)node.getFreeMemory()) / (float)node.getTotalMemory();
                        } catch (NoSuchFieldException e) {
                                // TODO Auto-generated catch block
                                e.printStackTrace();
                        }
                        JobRegistry nodeJR = new JobRegistryImpl(node.getFullName());
                        synchronized(nodeJR) {
                                vm_number_c2 += Utility.getAllRunningTasks(nodeJR);
                        }
                        nb++;
                }
                mean_load_cpu_c2 = mean_load_cpu_c2 / nb;
                mean_load_mem_c2 = mean_load_mem_c2 / nb;
                
                float z1, z2;
                if (vm_number_c1 == 0) {
                        z1 = 1;
                }
                else {
                        z1 = Math.max(mean_load_cpu_c1 / vm_number_c1, mean_load_mem_c1 / vm_number_c1);
                }
                if (vm_number_c2 == 0) {
                        z2 = 1;
                }
                else {
                        z2 = Math.max(mean_load_cpu_c2 / vm_number_c2, mean_load_mem_c2 / vm_number_c2);
                }
                
                if (z1 > z2)
                        return 1;
                else if (z1 > z2)
                        return -1;
                else 
                        return 0;
        }
}
//static bool ranking_clouds(metasched_cloud_t c1, metasched_cloud_t c2) {
//float z1 = std::max((float)c1.load_cpu / (float)c1.vm_number
//                  , (float)c1.load_memory/(float)c1.vm_number);
//float z2 = std::max((float)c2.load_cpu / (float)c2.vm_number
//                  , (float)c2.load_memory/(float)c2.vm_number);
//return (z1 <= z2);
//}