Changeset 269


Ignore:
Timestamp:
04/13/12 09:49:40 (13 years ago)
Author:
piontek
Message:
 
Location:
xssim/branches/tpiontek/src
Files:
1 added
3 edited
1 copied
5 moved

Legend:

Unmodified
Added
Removed

  • xssim/branches/tpiontek/src/example/localplugin/FCFSConsolidationClusterLocalPlugin.java

    r192 r269  
    66import java.util.Collections; 
    77import java.util.Comparator; 
    8 import java.util.HashMap; 
    98import java.util.List; 
    10 import java.util.Map; 
    119import java.util.Properties; 
    1210 
    13 import schedframe.resources.units.Memory; 
    14 import schedframe.resources.units.ResourceUnit; 
     11import schedframe.resources.PowerState; 
    1512import schedframe.scheduling.TaskInterface; 
    1613import schedframe.scheduling.events.SchedulingEvent; 
    1714import schedframe.scheduling.plugin.grid.ModuleList; 
    18 import schedframe.scheduling.utils.ResourceParameterName; 
    1915import test.rewolucja.GSSIMJobInterface; 
    20 import test.rewolucja.resources.ProcessingElements; 
    21 import test.rewolucja.resources.ResourceStatus; 
    2216import test.rewolucja.resources.manager.implementation.ClusterResourceManager; 
    2317import test.rewolucja.resources.manager.interfaces.ResourceManagerInterface; 
    24 import test.rewolucja.resources.physical.base.ComputingResource; 
    2518import test.rewolucja.resources.physical.implementation.ComputingNode; 
    2619import test.rewolucja.scheduling.JobRegistryInterface; 
    … …  
    3124 
    3225public class FCFSConsolidationClusterLocalPlugin extends BaseLocalPlugin { 
     26         
     27        private int scenario = 1; 
    3328 
    3429        public FCFSConsolidationClusterLocalPlugin () { 
    … …  
    5651                                if (task.getStatus() == Gridlet.READY) { 
    5752 
    58                                         Map<ResourceParameterName, ResourceUnit> choosenResources = chooseResourcesForExecution(resourceManager, task); 
    59                                         if (choosenResources  != null) { 
    60                                                 addToSchedulingPlan(plan, task, choosenResources); 
     53                                        ComputingNode node = chooseResourcesForExecution(resourceManager, PowerState.ON, task); 
     54                                        if (node  != null) { 
     55                                                System.out.println("Uruchamiam na zasobie: " + node.getName()); 
     56                                                addToSchedulingPlan(plan, task, node.getName()); 
    6157                                        }  
     58                                        else 
     59                                        { 
     60                                                node = chooseResourcesForExecution(resourceManager, PowerState.OFF, task); 
     61                                                 
     62                                                if( node != null) 
     63                                                { 
     64                                                        System.out.println("Wlaczam wezel: " + node.getName()); 
     65                                                        node.getPowerInterface().setPowerState( PowerState.ON); 
     66                                                        i--; 
     67                                                }        
     68                                        } 
    6269                                } 
    6370                        } 
     71                         
     72                        switch( scenario) 
     73                        { 
     74                                case 0: break; 
     75                                case 1: 
     76                                        List<ComputingNode> nodes = resourceManager.getComputingNodes(); 
     77                                        for( ComputingNode node : nodes) 
     78                                                if( node.getFreeProcessors().size() == node.getProcessorsNumber()) 
     79                                                { 
     80                                                        node.getPowerInterface().setPowerState( PowerState.OFF); 
     81                                                } 
     82                                        break; 
     83                        } 
     84                         
    6485 
    6586                        break; 
    … …  
    6889        } 
    6990         
    70         private HashMap<ResourceParameterName, ResourceUnit> chooseResourcesForExecution(ClusterResourceManager resourceManager, TaskInterface<?> task) { 
     91        private ComputingNode chooseResourcesForExecution(ClusterResourceManager resourceManager, PowerState status, TaskInterface<?> task) { 
    7192 
    7293                List<ComputingNode> nodes = resourceManager.getComputingNodes(); 
    73                 nodes = findSuitableNodes(task, nodes); 
     94                nodes = findSuitableNodes(task, status, nodes); 
     95                 
    7496                Collections.sort(nodes, new Comparator<ComputingNode>(){ 
    7597                    public int compare(ComputingNode node1, ComputingNode node2){     
    … …  
    7799                    } 
    78100                }); 
     101                 
    79102                if(nodes.size() > 0) 
    80                 { 
    81                         ComputingNode node = nodes.get(0); 
    82                         HashMap<ResourceParameterName, ResourceUnit> map = new HashMap<ResourceParameterName, ResourceUnit>(); 
    83                         List<ComputingResource> choosenResources =  new ArrayList<ComputingResource>(); 
    84                         int cpuRequest; 
    85                         try { 
    86                                 cpuRequest = Double.valueOf(task.getCpuCntRequest()).intValue(); 
    87                         } catch (NoSuchFieldException e) { 
    88                                 cpuRequest = 1; 
    89                         } 
    90                         for (int i = 0; i < node.getProcessors().size() && cpuRequest > 0; i++) { 
    91                                 if (node.getProcessors().get(i).getStatus() == ResourceStatus.FREE) { 
    92                                         choosenResources.add(node.getProcessors().get(i)); 
    93                                         cpuRequest--; 
    94                                 } 
    95                         } 
    96                         ProcessingElements result = new ProcessingElements(node.getName()); 
    97                         result.addAll(choosenResources); 
    98                         map.put(ResourceParameterName.PROCESSINGELEMENTS, result); 
    99                          
    100                         int memoryRequest; 
    101                         try { 
    102                                 memoryRequest = Double.valueOf(task.getMemoryRequest()).intValue(); 
    103                         } catch (NoSuchFieldException e) { 
    104                                 memoryRequest = 0; 
    105                         } 
    106                         if (memoryRequest != 0) { 
    107                                 Memory memory = new Memory(node.getMemoryUnit(), memoryRequest, memoryRequest); 
    108                                 map.put(ResourceParameterName.MEMORY, memory); 
    109                         } 
    110                         return map; 
    111                 } else  
    112                         return null; 
     103                        return nodes.get(0); 
     104                                  
     105                return null; 
    113106        } 
    114107         
    115         private List<ComputingNode> findSuitableNodes(TaskInterface<?> task, List<ComputingNode> nodes){ 
     108        private List<ComputingNode> findSuitableNodes(TaskInterface<?> task, PowerState status, List<ComputingNode> nodes){ 
    116109                int cpuRequest; 
    117110                try { 
    … …  
    120113                        cpuRequest = 1; 
    121114                } 
    122                 int memoryRequest; 
    123                 try { 
    124                         memoryRequest = Double.valueOf(task.getMemoryRequest()).intValue(); 
    125                 } catch (NoSuchFieldException e) { 
    126                         memoryRequest = 0; 
     115                 
     116                List<ComputingNode> suitableNodes = new ArrayList<ComputingNode>(); 
     117                for(ComputingNode node: nodes) 
     118                { 
     119                                switch( status) 
     120                                { 
     121                                        case ON: 
     122                                                if(node.getFreeProcessorsNumber() >= cpuRequest) 
     123                                                        suitableNodes.add(node); 
     124                                                break; 
     125                                        case OFF: 
     126                                                if( node.getProcessorsNumber() >= cpuRequest) 
     127                                                        suitableNodes.add(node); 
     128                                                break; 
     129                                } 
    127130                } 
    128                 List<ComputingNode> suitableNodes = new ArrayList<ComputingNode>(); 
    129                 for(ComputingNode node: nodes){ 
    130                         if(node.getFreeProcessorsNumber() >= cpuRequest && node.getFreeMemory() >= memoryRequest){ 
    131                                 suitableNodes.add(node); 
    132                         } 
    133                 } 
     131         
    134132                return suitableNodes; 
    135133        } 

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

    r258 r269  
    22 
    33import gridsim.Gridlet; 
     4import gridsim.gssim.ResourceHistoryItem; 
     5import gridsim.gssim.SubmittedTask; 
    46 
    57import java.util.ArrayList; 
    … …  
    1113import schedframe.scheduling.TaskInterface; 
    1214import schedframe.scheduling.events.SchedulingEvent; 
     15import schedframe.scheduling.events.TaskFinishedEvent; 
    1316import schedframe.scheduling.plugin.grid.ModuleList; 
     17import schedframe.scheduling.utils.ResourceParameterName; 
    1418import test.rewolucja.GSSIMJobInterface; 
    1519import test.rewolucja.energy.profile.PStateType; 
     20import test.rewolucja.resources.ProcessingElements; 
    1621import test.rewolucja.resources.ResourceStatus; 
    1722import test.rewolucja.resources.ResourceType; 
    1823import test.rewolucja.resources.manager.implementation.ClusterResourceManager; 
    1924import test.rewolucja.resources.manager.interfaces.ResourceManagerInterface; 
     25import test.rewolucja.resources.physical.base.ComputingResource; 
    2026import test.rewolucja.resources.physical.implementation.ComputingNode; 
    2127import test.rewolucja.resources.physical.implementation.Processor; 
    2228import test.rewolucja.scheduling.JobRegistryInterface; 
     29import test.rewolucja.scheduling.UsedResourceList; 
    2330import test.rewolucja.scheduling.plan.SchedulingPlanInterfaceNew; 
    2431import test.rewolucja.scheduling.plan.SchedulingPlanNew; 
    … …  
    3138        private boolean init = true; 
    3239         
    33         int scenario = 2; 
     40        int scenario = 3; 
    3441        String prefered = null; 
    3542         
    … …  
    5966                // Different actions for different events are possible. 
    6067                switch (event.getType()) { 
     68                case TASK_FINISHED: 
     69                        if( scenario == 2) 
     70                        {        
     71                                TaskFinishedEvent finEvent = (TaskFinishedEvent) event; 
     72                                SubmittedTask subTask = jobRegistry.getSubmittedTask(finEvent.getJobId(), finEvent.getTaskId()); 
     73                                UsedResourceList<ResourceHistoryItem> usedResourcesList = subTask.getUsedResources(); 
     74                                ProcessingElements pes = (ProcessingElements)usedResourcesList.getLast().getResourceUnits().get(ResourceParameterName.PROCESSINGELEMENTS); 
     75                                 
     76                                for( ComputingResource cr : pes) 
     77                                { 
     78                                        ((Processor)cr).getPowerInterface().setPowerState( PowerState.OFF); 
     79                                } 
     80                        } 
     81                         
    6182                case START_TASK_EXECUTION: 
    62                 case TASK_FINISHED: 
    6383                        // our tasks are placed only in first queue (see 
    6484                        // BaseLocalPlugin.placeJobsInQueues() method) 
    … …  
    7696                                        if (node != null) { 
    7797                                                List<Processor> cpus = chooseProcessorsForExecution(node, ResourceStatus.FREE, task); 
     98                                                 
     99                                                int type = Integer.parseInt( task.getJobId()) % 4; 
     100                                                String model = cpus.get(0).getComputingNode().getCategory().getName(); 
     101                                                //System.out.println(type + " -> " + model); 
     102                                                 
    78103                                                addToSchedulingPlan(plan, task, cpus); 
    79104                                        } 
    … …  
    91116                                                                for( Processor cpu: cpus) 
    92117                                                                        cpu.getPowerInterface().setPowerState( PowerState.ON); 
    93                                                                 } 
     118                                                                 
     119                                                                i--; 
     120                                                        } 
    94121                                                        break; 
    95122                                                } 
    … …  
    163190        private ComputingNode chooseRandomProvider(ClusterResourceManager resourceManager, ResourceStatus status, TaskInterface<?> task) { 
    164191                 
     192                String preferedNode = null; 
     193                 
    165194                int cpuRequest = getCpuRequest(task); 
    166195                 
    167196                List<ComputingNode> nodes = null; 
    168197                 
    169                 String prefered = null; 
    170                  
    171                 nodes = findSuitableNodes(prefered, cpuRequest, status, resourceManager.getComputingNodes()); 
    172                 if( nodes.size() > 0) 
     198                switch( scenario) 
     199                { 
     200                        case 3: 
     201                                int type = Integer.parseInt( task.getJobId()) % 4; 
     202                                switch( type) 
     203                                { 
     204                                        case 0: preferedNode = "B"; break; 
     205                                        default: preferedNode = "A"; break; 
     206                                } 
     207                                break; 
     208                        default: 
     209                                preferedNode = prefered; 
     210                                break; 
     211                                 
     212                } 
     213                 
     214                nodes = findSuitableNodes(preferedNode, cpuRequest, status, resourceManager.getComputingNodes()); 
     215                switch( nodes.size()) 
     216                { 
     217                        case 0: break; 
     218                        case 1: return nodes.get(0); 
     219                        default: 
     220                                int nodeIdx = rand.nextInt(nodes.size()); 
     221                                ComputingNode node = nodes.get(nodeIdx);                 
     222                                return node; 
     223                } 
     224                 
     225                 
     226                if( preferedNode != null) 
    173227                {        
    174                         int nodeIdx = rand.nextInt(nodes.size()); 
    175                         ComputingNode node = nodes.get(nodeIdx); 
    176                                                  
    177                         return node; 
    178                 } 
    179                 else 
    180                 { 
    181                         System.out.println("NO resources: " + prefered); 
    182                 } 
    183                  
    184                 if( prefered != null) 
    185                 {        
    186                         nodes = findSuitableNodes( getUnprefered(), cpuRequest, status, resourceManager.getComputingNodes()); 
    187                         if( nodes.size() > 0) 
    188                         {        
    189                                 int nodeIdx = rand.nextInt(nodes.size()); 
    190                                 ComputingNode node = nodes.get(nodeIdx); 
    191                                                          
    192                                 return node; 
     228                        nodes = findSuitableNodes( getUnprefered(preferedNode), cpuRequest, status, resourceManager.getComputingNodes()); 
     229                        switch( nodes.size()) 
     230                        { 
     231                                case 0: break; 
     232                                case 1: return nodes.get(0); 
     233                                default:  
     234                                        int nodeIdx = rand.nextInt(nodes.size()); 
     235                                        ComputingNode node = nodes.get(nodeIdx);                 
     236                                        return node; 
    193237                        } 
    194238                } 
    … …  
    215259        } 
    216260         
    217         private String getUnprefered() 
     261        private String getUnprefered( String preferedNode) 
    218262        { 
    219                 if( prefered.equals("A")) 
     263                if( preferedNode.equals("A")) 
    220264                        return "B"; 
    221265                 
    222                 if( prefered.equals("B")) 
     266                if( preferedNode.equals("B")) 
    223267                        return "A"; 
    224268                 

  • xssim/branches/tpiontek/src/example/timeestimation/ExecTimeEstimationPlugin.java

    r250 r269  
    5454                if( type == 0 && ((Processor)pes.get(0)).getComputingNode().getCategory().getName().equals("A")) 
    5555                { 
    56                         factor = 0.6; 
     56                        factor = 0.5; 
    5757                } 
    5858                 

  • xssim/branches/tpiontek/src/simulator/stats/implementation/GSSimStatistics.java

    r267 r269  
    203203                e = System.currentTimeMillis(); 
    204204                log.info("time in sec: " + ((e - s) / 1000)); 
     205                 
     206                System.out.println("SIMULATION DURATION = " + (endSimulationTime - startSimulationTime) / 1000); 
    205207        } 
    206208 
Note: See TracChangeset for help on using the changeset viewer.