Changeset 269 for xssim/branches/tpiontek/src/example/localplugin/FCFSPreferedRandomClusterLocalPlugin.java

Timestamp:

04/13/12 09:49:40 (13 years ago)

Author:

piontek

Message:

 

File:

• xssim/branches/tpiontek/src/example/localplugin/FCFSPreferedRandomClusterLocalPlugin.java (modified) (8 diffs)

xssim/branches/tpiontek/src/example/localplugin/FCFSPreferedRandomClusterLocalPlugin.java

@@ -2 +2 @@
 
 import gridsim.Gridlet;
+import gridsim.gssim.ResourceHistoryItem;
+import gridsim.gssim.SubmittedTask;
 
 import java.util.ArrayList;
@@ -11 +13 @@
 import schedframe.scheduling.TaskInterface;
 import schedframe.scheduling.events.SchedulingEvent;
+import schedframe.scheduling.events.TaskFinishedEvent;
 import schedframe.scheduling.plugin.grid.ModuleList;
+import schedframe.scheduling.utils.ResourceParameterName;
 import test.rewolucja.GSSIMJobInterface;
 import test.rewolucja.energy.profile.PStateType;
+import test.rewolucja.resources.ProcessingElements;
 import test.rewolucja.resources.ResourceStatus;
 import test.rewolucja.resources.ResourceType;
 import test.rewolucja.resources.manager.implementation.ClusterResourceManager;
 import test.rewolucja.resources.manager.interfaces.ResourceManagerInterface;
+import test.rewolucja.resources.physical.base.ComputingResource;
 import test.rewolucja.resources.physical.implementation.ComputingNode;
 import test.rewolucja.resources.physical.implementation.Processor;
 import test.rewolucja.scheduling.JobRegistryInterface;
+import test.rewolucja.scheduling.UsedResourceList;
 import test.rewolucja.scheduling.plan.SchedulingPlanInterfaceNew;
 import test.rewolucja.scheduling.plan.SchedulingPlanNew;
@@ -31 +38 @@
         private boolean init = true;
         
-        int scenario = 2;
+        int scenario = 3;
         String prefered = null;
         
@@ -59 +66 @@
                 // Different actions for different events are possible.
                 switch (event.getType()) {
+                case TASK_FINISHED:
+                        if( scenario == 2)
+                        {       
+                                TaskFinishedEvent finEvent = (TaskFinishedEvent) event;
+                                SubmittedTask subTask = jobRegistry.getSubmittedTask(finEvent.getJobId(), finEvent.getTaskId());
+                                UsedResourceList<ResourceHistoryItem> usedResourcesList = subTask.getUsedResources();
+                                ProcessingElements pes = (ProcessingElements)usedResourcesList.getLast().getResourceUnits().get(ResourceParameterName.PROCESSINGELEMENTS);
+                                
+                                for( ComputingResource cr : pes)
+                                {
+                                        ((Processor)cr).getPowerInterface().setPowerState( PowerState.OFF);
+                                }
+                        }
+                        
                 case START_TASK_EXECUTION:
-                case TASK_FINISHED:
                         // our tasks are placed only in first queue (see
                         // BaseLocalPlugin.placeJobsInQueues() method)
@@ -76 +96 @@
                                         if (node != null) {
                                                 List<Processor> cpus = chooseProcessorsForExecution(node, ResourceStatus.FREE, task);
+                                                
+                                                int type = Integer.parseInt( task.getJobId()) % 4;
+                                                String model = cpus.get(0).getComputingNode().getCategory().getName();
+                                                //System.out.println(type + " -> " + model);
+                                                
                                                 addToSchedulingPlan(plan, task, cpus);
                                         }
@@ -91 +116 @@
                                                                 for( Processor cpu: cpus)
                                                                         cpu.getPowerInterface().setPowerState( PowerState.ON);
-                                                                }
+                                                                
+                                                                i--;
+                                                        }
                                                         break;
                                                 }
@@ -163 +190 @@
         private ComputingNode chooseRandomProvider(ClusterResourceManager resourceManager, ResourceStatus status, TaskInterface<?> task) {
                 
+                String preferedNode = null;
+                
                 int cpuRequest = getCpuRequest(task);
                 
                 List<ComputingNode> nodes = null;
                 
-                String prefered = null;
-                
-                nodes = findSuitableNodes(prefered, cpuRequest, status, resourceManager.getComputingNodes());
-                if( nodes.size() > 0)
+                switch( scenario)
+                {
+                        case 3:
+                                int type = Integer.parseInt( task.getJobId()) % 4;
+                                switch( type)
+                                {
+                                        case 0: preferedNode = "B"; break;
+                                        default: preferedNode = "A"; break;
+                                }
+                                break;
+                        default:
+                                preferedNode = prefered;
+                                break;
+                                
+                }
+                
+                nodes = findSuitableNodes(preferedNode, cpuRequest, status, resourceManager.getComputingNodes());
+                switch( nodes.size())
+                {
+                        case 0: break;
+                        case 1: return nodes.get(0);
+                        default:
+                                int nodeIdx = rand.nextInt(nodes.size());
+                                ComputingNode node = nodes.get(nodeIdx);                
+                                return node;
+                }
+                
+                
+                if( preferedNode != null)
                 {       
-                        int nodeIdx = rand.nextInt(nodes.size());
-                        ComputingNode node = nodes.get(nodeIdx);
-                                                
-                        return node;
-                }
-                else
-                {
-                        System.out.println("NO resources: " + prefered);
-                }
-                
-                if( prefered != null)
-                {       
-                        nodes = findSuitableNodes( getUnprefered(), cpuRequest, status, resourceManager.getComputingNodes());
-                        if( nodes.size() > 0)
-                        {       
-                                int nodeIdx = rand.nextInt(nodes.size());
-                                ComputingNode node = nodes.get(nodeIdx);
-                                                        
-                                return node;
+                        nodes = findSuitableNodes( getUnprefered(preferedNode), cpuRequest, status, resourceManager.getComputingNodes());
+                        switch( nodes.size())
+                        {
+                                case 0: break;
+                                case 1: return nodes.get(0);
+                                default: 
+                                        int nodeIdx = rand.nextInt(nodes.size());
+                                        ComputingNode node = nodes.get(nodeIdx);                
+                                        return node;
                         }
                 }
@@ -215 +259 @@
         }
         
-        private String getUnprefered()
+        private String getUnprefered( String preferedNode)
         {
-                if( prefered.equals("A"))
+                if( preferedNode.equals("A"))
                         return "B";
                 
-                if( prefered.equals("B"))
+                if( preferedNode.equals("B"))
                         return "A";