source: xssim/src/example/gridplugin/GridFCFSLoadBalancingPlugin.java @ 104

package example.gridplugin;


import java.util.List;
import java.util.Properties;

import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;

import schedframe.resources.ResourceDescription;
import schedframe.scheduling.TaskInterface;
import schedframe.scheduling.events.SchedulingEvent;
import schedframe.scheduling.plugin.SchedulingPluginConfiguration;
import schedframe.scheduling.plugin.configuration.DefaultConfiguration;
import schedframe.scheduling.plugin.grid.Module;
import schedframe.scheduling.plugin.grid.ModuleList;
import schedframe.scheduling.plugin.grid.ResourceDiscovery;
import test.rewolucja.GSSIMJobInterface;
import test.rewolucja.resources.manager.interfaces.ResourceManagerInterface;
import test.rewolucja.scheduling.JobRegistryInterface;
import test.rewolucja.scheduling.plan.AllocationNew;
import test.rewolucja.scheduling.plan.ScheduledTaskNew;
import test.rewolucja.scheduling.plan.SchedulingPlanInterfaceNew;
import test.rewolucja.scheduling.plan.SchedulingPlanNew;
import test.rewolucja.scheduling.queue.GSSIMQueue;
import test.rewolucja.scheduling.queue.QueueList;

public class GridFCFSLoadBalancingPlugin  extends BaseGlobalPlugin {

        private Log log = LogFactory.getLog(GridFCFSLoadBalancingPlugin.class);
        
        public SchedulingPlanInterfaceNew schedule(SchedulingEvent event,
                        QueueList queues, 
                        JobRegistryInterface jobRegistry,
                        ResourceManagerInterface resourceManager, ModuleList modules)  {
        
                ResourceDiscovery resources = null;
                for(int i = 0; i < modules.size(); i++){
                        Module m = modules.get(i);
                        switch(m.getType()){
                                case RESOURCE_DISCOVERY: resources = (ResourceDiscovery) m;
                                        break;
                        }
                }
                
                SchedulingPlanNew plan = new SchedulingPlanNew();
                
                GSSIMQueue q = queues.get(0);
                int size = q.size();
                
                // order of the resources on this list is not determined
                List<ResourceDescription> availableResources = resources.getResources(null);
                int resourceIdx = -1;
                
                for(int i = 0; i < size; i++) {
                        GSSIMJobInterface<?> job = q.remove(0);
                        TaskInterface<?> task = (TaskInterface<?>)job;

                        resourceIdx = findLeastLoadedResourceIdx(availableResources);
                        ResourceDescription rd = availableResources.get(resourceIdx);
                        
                        AllocationNew allocation = new AllocationNew();
                        allocation.setProcessesCount(1);
                        allocation.setProviderName(rd.getProvider().getProviderId());
                        
                        ScheduledTaskNew scheduledTask = new ScheduledTaskNew(task);
                        scheduledTask.setTaskId(task.getId());
                        scheduledTask.setJobId(task.getJobId());
                        scheduledTask.addAllocation(allocation);                
                        
                        plan.addTask(scheduledTask);
                }
                return plan;
                
        }

        public SchedulingPluginConfiguration getConfiguration() {
                return DefaultConfiguration.forGridPlugin();
        }

        public String getName() {
                return getClass().getName();
        }

        public void init(Properties properties) {
                // no extra initialization is expected.
        }
        
        private int findLeastLoadedResourceIdx(List<ResourceDescription> availableResources){
                
                int resourceIdx = -1;
                long maxLoad = Long.MAX_VALUE;
                for(int i = 0; i < availableResources.size(); i++){
                        ResourceDescription rd = availableResources.get(i);
                        try {
                                if(rd.getQueueLoad(null) < maxLoad){
                                        resourceIdx = i;
                                        maxLoad = rd.getQueueLoad(null);
                                }
                        } catch (NoSuchFieldException e) {
                                log.warn(e.getMessage());
                        }
                }
                return resourceIdx;
        }

}