Ignore:
Timestamp:
11/26/13 11:56:07 (11 years ago)
Author:
wojtekp
Message:
 
Location:
DCWoRMS/branches/coolemall/src/example/localplugin
Files:
8 added
10 edited

Legend:

Unmodified
Added
Removed

  • DCWoRMS/branches/coolemall/src/example/localplugin/FCFSBF_ClusterPlugin.java

    r575 r1207  
    145145                List<ComputingResource> nodes; 
    146146                Properties properties = new Properties(); 
    147                 properties.setProperty("type", StandardResourceType.ComputingNode.getName()); 
     147                properties.setProperty("type", StandardResourceType.Node.getName()); 
    148148                // properties.setProperty("status", ResourceStatus.FREE.toString()); 
    149149                nodes = (List<ComputingResource>) unitsManager.filterResources(properties); 
    150150                 
    151151                //always return the same node from the list 
    152                 return nodes.get(0).getName(); 
     152                return nodes.get(0).getFullName(); 
    153153        } 
    154154 

  • DCWoRMS/branches/coolemall/src/example/localplugin/FCFSBF_ConsolidationClusterPlugin.java

    r574 r1207  
    9898                                } 
    9999                        } 
    100                         ProcessingElements result = new ProcessingElements(node.getName()); 
     100                        ProcessingElements result = new ProcessingElements(node.getFullName()); 
    101101                        result.addAll(choosenResources); 
    102102                        map.put(StandardResourceUnitName.PE, result); 

  • DCWoRMS/branches/coolemall/src/example/localplugin/FCFSBF_FanManagementClusterPlugin.java

    r778 r1207  
    88 
    99import schedframe.events.scheduling.SchedulingEvent; 
     10import schedframe.resources.StandardResourceType; 
    1011import schedframe.resources.computing.ComputingNode; 
    1112import schedframe.resources.computing.profiles.energy.airthroughput.StandardAirThroughputStateName; 
    1213import schedframe.resources.computing.profiles.energy.airthroughput.UserAirThroughputStateName; 
     14import schedframe.resources.devices.Device; 
    1315import schedframe.scheduling.manager.resources.ClusterResourceManager; 
    1416import schedframe.scheduling.manager.resources.ResourceManager; 
    … …  
    5456                                        if (node != null) { 
    5557                                                //if there are two or more tasks ( running on the given node then 
    56                                                 if(new JobRegistryImpl(node.getName()).getRunningTasks().size() > 0) 
    57                                                         node.getAirThroughputInterface().setAirThroughputState(new UserAirThroughputStateName("FAN_ON_TURBO")); 
    58                                                 else  
    59                                                         node.getAirThroughputInterface().setAirThroughputState(StandardAirThroughputStateName.FAN_ON); 
     58                                                if(new JobRegistryImpl(node.getFullName()).getRunningTasks().size() > 0){ 
     59                                                        List<Device> devices = node.getResourceCharacteristic().getDevices(); 
     60                                                        for(Device dev : devices){ 
     61                                                                if(dev.getType().equals(StandardResourceType.Fan)){ 
     62                                                                        dev.getAirThroughputInterface().setAirThroughputState(new UserAirThroughputStateName("FAN_ON_TURBO")); 
     63                                                                } 
     64                                                        } 
     65                                                } 
     66                                                else { 
     67                                                        List<Device> devices = node.getResourceCharacteristic().getDevices(); 
     68                                                        for(Device dev : devices){ 
     69                                                                if(dev.getType().equals(StandardResourceType.Fan)){ 
     70                                                                        dev.getAirThroughputInterface().setAirThroughputState(StandardAirThroughputStateName.ON);        
     71                                                                } 
     72                                                        } 
     73                                                } 
    6074                                                notSelectedNodes.remove(node); 
    61                                                 addToSchedulingPlan(plan, task, node.getName()); 
     75                                                addToSchedulingPlan(plan, task, node.getFullName()); 
    6276                                        } 
    6377                                } 
    … …  
    98112        private void adjustOtherFans(List<ComputingNode> nodes){ 
    99113                for(ComputingNode node : nodes){ 
     114                        List<Device> devices = node.getResourceCharacteristic().getDevices(); 
    100115                        if(node.getFreeProcessorsNumber() == node.getProcessorsNumber()){ 
    101                                 node.getAirThroughputInterface().setAirThroughputState(StandardAirThroughputStateName.FAN_OFF); 
    102                         } else if(new JobRegistryImpl(node.getName()).getRunningTasks().size() > 1) 
    103                                 node.getAirThroughputInterface().setAirThroughputState(new UserAirThroughputStateName("FAN_ON_TURBO")); 
    104                         else  
    105                                 node.getAirThroughputInterface().setAirThroughputState(StandardAirThroughputStateName.FAN_ON); 
     116                                for(Device dev : devices){ 
     117                                        if(dev.getType().equals(StandardResourceType.Fan)){ 
     118                                                dev.getAirThroughputInterface().setAirThroughputState(StandardAirThroughputStateName.OFF); 
     119                                        } 
     120                                } 
     121                        } else if(new JobRegistryImpl(node.getFullName()).getRunningTasks().size() > 1){ 
     122                                for(Device dev : devices){ 
     123                                        if(dev.getType().equals(StandardResourceType.Fan)){ 
     124                                                dev.getAirThroughputInterface().setAirThroughputState(new UserAirThroughputStateName("FAN_ON_TURBO")); 
     125                                        } 
     126                                } 
     127                        } 
     128                        else { 
     129                                for(Device dev : devices){ 
     130                                        if(dev.getType().equals(StandardResourceType.Fan)){ 
     131                                                dev.getAirThroughputInterface().setAirThroughputState(StandardAirThroughputStateName.ON); 
     132                                        } 
     133                                } 
     134                        } 
    106135                } 
    107136        } 

  • DCWoRMS/branches/coolemall/src/example/localplugin/FCFSBF_NodePowerManagementClusterPlugin.java

    r531 r1207  
    9090                                } 
    9191                        } 
    92                         ProcessingElements result = new ProcessingElements(nodes.get(0).getName()); 
     92                        ProcessingElements result = new ProcessingElements(nodes.get(0).getFullName()); 
    9393                        result.addAll(choosenResources); 
    9494                        map.put(StandardResourceUnitName.PE, result); 

  • DCWoRMS/branches/coolemall/src/example/localplugin/FCFSBF_RandomClusterPlugin.java

    r574 r1207  
    6161                List<ComputingNode> nodes = resourceManager.getComputingNodes(); 
    6262                int nodeIdx = rand.nextInt(nodes.size()); 
    63                 return nodes.get(nodeIdx).getName(); 
     63                return nodes.get(nodeIdx).getFullName(); 
    6464        } 
    6565 

  • DCWoRMS/branches/coolemall/src/example/localplugin/coolemall/FCFSBF_RECS_SP.java

    r1100 r1207  
    66import schedframe.events.scheduling.SchedulingEvent; 
    77import schedframe.exceptions.ResourceException; 
    8 import schedframe.resources.CoolEmAllResourceType; 
     8import schedframe.resources.StandardResourceType; 
    99import schedframe.resources.computing.ComputingResource; 
    1010import schedframe.scheduling.manager.resources.ClusterResourceManager; 
    … …  
    6464                List<ComputingResource> nodes = null; 
    6565                try { 
    66                         nodes = (List<ComputingResource>) resourceManager.getResourcesOfType(CoolEmAllResourceType.Node); 
     66                        nodes = (List<ComputingResource>) resourceManager.getResourcesOfType(StandardResourceType.Node); 
    6767                } catch (ResourceException e) { 
    6868                        // TODO Auto-generated catch block 
    … …  
    7070                } 
    7171                int nodeIdx = rand.nextInt(nodes.size()); 
    72                 return nodes.get(nodeIdx).getName(); 
     72                return nodes.get(nodeIdx).getFullName(); 
    7373        } 
    7474 

  • DCWoRMS/branches/coolemall/src/example/localplugin/coolemall/computebox1/CB1_FCFS_Random_SP.java

    r1099 r1207  
    11package example.localplugin.coolemall.computebox1; 
    22 
     3import java.util.ArrayList; 
     4import java.util.HashMap; 
    35import java.util.List; 
     6import java.util.Map; 
    47import java.util.Random; 
    58 
    69import schedframe.events.scheduling.SchedulingEvent; 
    710import schedframe.exceptions.ResourceException; 
    8 import schedframe.resources.CoolEmAllResourceType; 
     11import schedframe.resources.ResourceStatus; 
     12import schedframe.resources.StandardResourceType; 
    913import schedframe.resources.computing.ComputingResource; 
     14import schedframe.resources.computing.Core; 
     15import schedframe.resources.computing.coolemall.Node; 
     16import schedframe.resources.units.ProcessingElements; 
     17import schedframe.resources.units.ResourceUnit; 
     18import schedframe.resources.units.ResourceUnitName; 
     19import schedframe.resources.units.StandardResourceUnitName; 
    1020import schedframe.scheduling.manager.resources.ClusterResourceManager; 
    1121import schedframe.scheduling.manager.resources.ResourceManager; 
    … …  
    1727import schedframe.scheduling.queue.TaskQueueList; 
    1828import schedframe.scheduling.tasks.TaskInterface; 
     29import testbed_hpc.Node_Fan_Mapping; 
    1930import example.localplugin.BaseLocalSchedulingPlugin; 
    2031import gridsim.dcworms.DCWormsTags; 
    … …  
    2637        public CB1_FCFS_Random_SP () { 
    2738                rand = new Random(47); 
     39                Node_Fan_Mapping.init(); 
    2840        } 
    2941 
    … …  
    4961                                if (task.getStatus() == DCWormsTags.READY) { 
    5062 
    51                                         String nodeName = chooseRandomProvider(resourceManager); 
    52                                         if (nodeName != null) { 
    53                                                 addToSchedulingPlan(plan, task, nodeName); 
     63                                        Map<ResourceUnitName, ResourceUnit> choosenResources = chooseResourcesForExecution(resourceManager, task); 
     64                                        if (choosenResources != null) { 
     65                                                addToSchedulingPlan(plan, task, choosenResources); 
    5466                                        } 
    5567                                } 
    … …  
    6173 
    6274        @SuppressWarnings("unchecked") 
    63         private String chooseRandomProvider(ClusterResourceManager resourceManager) { 
    64                 List<ComputingResource> nodes = null; 
     75        private Map<ResourceUnitName, ResourceUnit> chooseResourcesForExecution( 
     76                        ClusterResourceManager resourceManager, TaskInterface<?> task) { 
     77 
     78                Map<ResourceUnitName, ResourceUnit> map = new HashMap<ResourceUnitName, ResourceUnit>(); 
     79                 
     80                List<Node> nodes = null; 
    6581                try { 
    66                         nodes = (List<ComputingResource>) resourceManager.getResourcesOfType(CoolEmAllResourceType.Node); 
     82                        nodes = (List<Node>) resourceManager.getResourcesOfType(StandardResourceType.Node); 
    6783                } catch (ResourceException e) { 
    6884                        // TODO Auto-generated catch block 
    6985                        e.printStackTrace(); 
    7086                } 
    71                 int nodeIdx = rand.nextInt(nodes.size()); 
    72                 return nodes.get(nodeIdx).getName(); 
     87                List<Node> avNodes = filterNodes(nodes, task); 
     88                if(avNodes.size() == 0) 
     89                        return null; 
     90                Node node = randomNode(avNodes); 
     91                int cpuRequest; 
     92                try { 
     93                        cpuRequest = Double.valueOf(task.getCpuCntRequest()).intValue(); 
     94                } catch (NoSuchFieldException e) { 
     95                        cpuRequest = 0; 
     96                } 
     97 
     98                if (cpuRequest != 0) { 
     99 
     100                        List<ComputingResource> choosenResources = new ArrayList<ComputingResource>();   
     101                         
     102                        List<Core> cores = node.getCores();                      
     103                        for (int i = 0; i < cores.size() && cpuRequest > 0; i++) { 
     104                                if (cores.get(i).getStatus() == ResourceStatus.FREE) { 
     105                                        choosenResources.add(cores.get(i)); 
     106                                        cpuRequest--; 
     107                                } 
     108                        } 
     109                        if (cpuRequest > 0) { 
     110                                return null; 
     111                        } 
     112                        //choosenResources.add(node.getProcessors().get(0)); 
     113                        ProcessingElements pe = new ProcessingElements(); 
     114                        pe.addAll(choosenResources); 
     115                        map.put(StandardResourceUnitName.PE, pe); 
     116                        return map; 
     117                } 
     118                return null; 
     119        } 
     120         
     121        private List<Node> filterNodes(List<Node> nodes, TaskInterface<?> task){ 
     122                List<Node> filteredNodes = new ArrayList<Node>(); 
     123                int cpuRequest; 
     124                try { 
     125                        cpuRequest = Double.valueOf(task.getCpuCntRequest()).intValue(); 
     126                } catch (NoSuchFieldException e) { 
     127                        cpuRequest = 0; 
     128                } 
     129                for (Node node : nodes) { 
     130 
     131                        if (cpuRequest != 0) { 
     132 
     133                                List<Core> cores = node.getCores(); 
     134                                if (cores.size() < cpuRequest) { 
     135                                        if(cores.size() == 0){ 
     136                                                if(node.getProcessors().size() < cpuRequest) 
     137                                                        continue; 
     138                                        } 
     139                                } 
     140 
     141                                int freeCores = 0; 
     142                                for(Core core: cores){ 
     143                                        if(core.getStatus() == ResourceStatus.FREE) 
     144                                                freeCores++; 
     145                                } 
     146                                 
     147                                if(freeCores < cpuRequest) 
     148                                        continue; 
     149                                 
     150                                filteredNodes.add(node); 
     151                        } 
     152                } 
     153                 
     154                return filteredNodes; 
     155        } 
     156         
     157        private Node randomNode(List<Node> nodes){ 
     158                return nodes.get(rand.nextInt(nodes.size())); 
    73159        } 
    74160 

  • DCWoRMS/branches/coolemall/src/example/localplugin/coolemall/recs/RECS_FCFS_Consolidation_SP.java

    r1102 r1207  
    1010import schedframe.events.scheduling.SchedulingEvent; 
    1111import schedframe.exceptions.ResourceException; 
    12 import schedframe.resources.CoolEmAllResourceType; 
    1312import schedframe.resources.ResourceStatus; 
     13import schedframe.resources.StandardResourceType; 
    1414import schedframe.resources.computing.ComputingResource; 
    1515import schedframe.resources.computing.Processor; 
     16import schedframe.resources.computing.coolemall.Node; 
    1617import schedframe.resources.computing.profiles.energy.power.StandardPowerStateName; 
    17 import schedframe.resources.computing.recs.Node; 
    1818import schedframe.resources.units.Memory; 
    1919import schedframe.resources.units.ProcessingElements; 
    … …  
    5555                        List<Node> nodes; 
    5656                        try { 
    57                                 nodes = (List<Node>) resourceManager.getResourcesOfType(CoolEmAllResourceType.Node); 
     57                                nodes = (List<Node>) resourceManager.getResourcesOfType(StandardResourceType.Node); 
    5858                        } catch (ResourceException e) { 
    5959                                break; 
    … …  
    140140                                } 
    141141                        } 
    142                         ProcessingElements result = new ProcessingElements(node.getName()); 
     142                        ProcessingElements result = new ProcessingElements(node.getFullName()); 
    143143                        result.addAll(choosenResources); 
    144144                        map.put(StandardResourceUnitName.PE, result); 
    … …  
    183183        private void turnOffIdleNodes(List<Node> nodes){ 
    184184                for(Node node : nodes){ 
    185                         JobRegistry jr = new JobRegistryImpl(node.getName()); 
     185                        JobRegistry jr = new JobRegistryImpl(node.getFullName()); 
    186186                        if(jr.getRunningTasks().size() == 0) 
    187187                                node.getPowerInterface().setPowerState(StandardPowerStateName.OFF); 

  • DCWoRMS/branches/coolemall/src/example/localplugin/coolemall/recs/RECS_FCFS_LB_SP.java

    r1102 r1207  
    55import schedframe.events.scheduling.SchedulingEvent; 
    66import schedframe.exceptions.ResourceException; 
    7 import schedframe.resources.CoolEmAllResourceType; 
     7import schedframe.resources.StandardResourceType; 
    88import schedframe.resources.computing.ComputingResource; 
    9 import schedframe.resources.computing.recs.Node; 
     9import schedframe.resources.computing.coolemall.Node; 
    1010import schedframe.scheduling.manager.resources.ClusterResourceManager; 
    1111import schedframe.scheduling.manager.resources.ResourceManager; 
    … …  
    6262                List<ComputingResource> nodes = null; 
    6363                try { 
    64                         nodes = (List<ComputingResource>) resourceManager.getResourcesOfType(CoolEmAllResourceType.Node); 
     64                        nodes = (List<ComputingResource>) resourceManager.getResourcesOfType(StandardResourceType.Node); 
    6565                } catch (ResourceException e) { 
    6666                        // TODO Auto-generated catch block 
    … …  
    6868                } 
    6969                int nodeIdx = findLeastLoadedResourceIdx(nodes); 
    70                 return nodes.get(nodeIdx).getName(); 
     70                return nodes.get(nodeIdx).getFullName(); 
    7171        } 
    7272         
    … …  
    7777                for(int i = 0; i < nodes.size(); i++){ 
    7878                        Node node = (Node) nodes.get(i); 
    79                         JobRegistry jr = new JobRegistryImpl(node.getName()); 
     79                        JobRegistry jr = new JobRegistryImpl(node.getFullName()); 
    8080                        int totalLoad = jr.getRunningTasks().size();  
    8181                        if(totalLoad < minLoad){ 

  • DCWoRMS/branches/coolemall/src/example/localplugin/coolemall/recs/RECS_FCFS_Random_SP.java

    r1103 r1207  
    22 
    33import java.util.ArrayList; 
     4import java.util.HashMap; 
    45import java.util.List; 
     6import java.util.Map; 
    57import java.util.Random; 
    68 
    79import schedframe.events.scheduling.SchedulingEvent; 
    810import schedframe.exceptions.ResourceException; 
    9 import schedframe.resources.CoolEmAllResourceType; 
     11import schedframe.resources.ResourceStatus; 
     12import schedframe.resources.StandardResourceType; 
    1013import schedframe.resources.computing.ComputingNode; 
    11 import schedframe.resources.computing.profiles.energy.airthroughput.StandardAirThroughputStateName; 
     14import schedframe.resources.computing.ComputingResource; 
     15import schedframe.resources.computing.Core; 
     16import schedframe.resources.computing.profiles.energy.airthroughput.UserAirThroughputStateName; 
     17import schedframe.resources.devices.Device; 
     18import schedframe.resources.units.ProcessingElements; 
     19import schedframe.resources.units.ResourceUnit; 
     20import schedframe.resources.units.ResourceUnitName; 
     21import schedframe.resources.units.StandardResourceUnitName; 
    1222import schedframe.scheduling.manager.resources.ClusterResourceManager; 
    1323import schedframe.scheduling.manager.resources.ResourceManager; 
    … …  
    1929import schedframe.scheduling.queue.TaskQueueList; 
    2030import schedframe.scheduling.tasks.TaskInterface; 
     31import testbed_hpc.Node_Fan_Mapping; 
    2132import example.localplugin.BaseLocalSchedulingPlugin; 
    2233import gridsim.dcworms.DCWormsTags; 
    … …  
    2839        public RECS_FCFS_Random_SP () { 
    2940                rand = new Random(47); 
     41                Node_Fan_Mapping.init(); 
    3042        } 
    3143 
    … …  
    4759                        List<ComputingNode> notSelectedNodes = null; 
    4860                        try { 
    49                                 notSelectedNodes = (List<ComputingNode>) resourceManager.getResourcesOfType(CoolEmAllResourceType.Node); 
     61                                notSelectedNodes = (List<ComputingNode>) resourceManager.getResourcesOfType(StandardResourceType.Node); 
    5062                        } catch (ResourceException e) { 
    5163                                // TODO Auto-generated catch block 
    … …  
    5769                                // if status of the tasks in READY 
    5870                                if (task.getStatus() == DCWormsTags.READY) { 
    59                                         ComputingNode node = chooseRandomProvider(resourceManager); 
     71                                        Map<ResourceUnitName, ResourceUnit> choosenResources = chooseResourcesForExecution(resourceManager, task); 
     72                                        if (choosenResources != null) { 
     73                                                addToSchedulingPlan(plan, task, choosenResources); 
     74                                        } 
     75                                        /*ComputingNode node = chooseRandomProvider(resourceManager); 
    6076                                        if (node != null) { 
    61                                                 node.getAirThroughputInterface().setAirThroughputState(StandardAirThroughputStateName.FAN_ON); 
     77                                                //node.getAirThroughputInterface().setAirThroughputState(StandardAirThroughputStateName.FAN_ON); 
    6278                                                notSelectedNodes.remove(node); 
    6379                                                addToSchedulingPlan(plan, task, node.getName()); 
    64                                         } 
     80                                        }*/ 
    6581                                } 
    6682                        } 
    … …  
    7591                List<ComputingNode> nodes = null; 
    7692                try { 
    77                         nodes = (List<ComputingNode>) resourceManager.getResourcesOfType(CoolEmAllResourceType.Node); 
     93                        nodes = (List<ComputingNode>) resourceManager.getResourcesOfType(StandardResourceType.Node); 
    7894                } catch (ResourceException e) { 
    7995                        // TODO Auto-generated catch block 
    … …  
    94110                return filteredNodes; 
    95111        } 
     112         
     113        private Map<ResourceUnitName, ResourceUnit> chooseResourcesForExecution( 
     114                        ClusterResourceManager resourceManager, TaskInterface<?> task) { 
     115 
     116                Map<ResourceUnitName, ResourceUnit> map = new HashMap<ResourceUnitName, ResourceUnit>(); 
     117                 
     118                List<ComputingNode> nodes = null; 
     119                try { 
     120                        nodes = (List<ComputingNode>) resourceManager.getResourcesOfType(StandardResourceType.Node); 
     121                } catch (ResourceException e1) { 
     122                        // TODO Auto-generated catch block 
     123                        e1.printStackTrace(); 
     124                } 
     125                List<ComputingNode> avNodes = filterNodes(nodes, task); 
     126                if(avNodes.size() == 0) 
     127                        return null; 
     128                ComputingNode node = randomNode(avNodes); 
     129 
     130                int cpuRequest; 
     131                try { 
     132                        cpuRequest = Double.valueOf(task.getCpuCntRequest()).intValue(); 
     133                } catch (NoSuchFieldException e) { 
     134                        cpuRequest = 0; 
     135                } 
     136 
     137                if (cpuRequest != 0) { 
     138 
     139                        List<Core> cores = node.getProcessors().get(0).getCores(); 
     140 
     141                        List<ComputingResource> choosenResources = new ArrayList<ComputingResource>();                           
     142                        for (int i = 0; i < cores.size(); i++) { 
     143                                if (cores.get(i).getStatus() == ResourceStatus.FREE) { 
     144                                        //choosenResources.add(cores.get(i)); 
     145                                        cpuRequest--; 
     146                                } 
     147                        } 
     148                        if (cpuRequest > 0) { 
     149                                return null; 
     150                        } 
     151                        choosenResources.add(node.getProcessors().get(0)); 
     152                        ProcessingElements pe = new ProcessingElements(); 
     153                        pe.addAll(choosenResources); 
     154                        map.put(StandardResourceUnitName.PE, pe); 
     155                        return map; 
     156                } 
     157                return null; 
     158        } 
     159         
     160        private List<ComputingNode> filterNodes(List<ComputingNode> nodes, TaskInterface<?> task){ 
     161                List<ComputingNode> filteredNodes = new ArrayList<ComputingNode>(); 
     162                for (ComputingNode node : nodes) { 
     163                        int cpuRequest; 
     164                        try { 
     165                                cpuRequest = Double.valueOf(task.getCpuCntRequest()).intValue(); 
     166                        } catch (NoSuchFieldException e) { 
     167                                cpuRequest = 0; 
     168                        } 
     169 
     170                        if (cpuRequest != 0) { 
     171 
     172                                List<Core> cores = node.getProcessors().get(0).getCores(); 
     173                                if (cores.size() < cpuRequest) { 
     174                                        if(cores.size() == 0){ 
     175                                                if(node.getProcessors().size() < cpuRequest) 
     176                                                        continue; 
     177                                        } 
     178                                } 
     179 
     180                                int freeCores = 0; 
     181                                for(Core core: cores){ 
     182                                        if(core.getStatus() == ResourceStatus.FREE) 
     183                                                freeCores++; 
     184                                } 
     185                                 
     186                                if(freeCores != cores.size()) 
     187                                        continue; 
     188                                 
     189                                filteredNodes.add(node); 
     190                        } 
     191                } 
     192                 
     193                return filteredNodes; 
     194        } 
     195         
     196        private ComputingNode randomNode(List<ComputingNode> nodes){ 
     197                return nodes.get(rand.nextInt(nodes.size())); 
     198        } 
     199         
    96200        private void adjustOtherFans(List<ComputingNode> nodes) { 
    97201                for (ComputingNode node : nodes) { 
     202                         
    98203                        if (node.getProcessors().size() == node.getFreeProcessorsNumber()) { 
    99                                 node.getAirThroughputInterface().setAirThroughputState(StandardAirThroughputStateName.FAN_OFF); 
     204                                for(Device device: node.getParent().getResourceCharacteristic().getDevices()){ 
     205                                        if(device.getFullName().equals(Node_Fan_Mapping.getNode_fan().get(node.getFullName()))){ 
     206                                                device.getAirThroughputInterface().setAirThroughputState(new UserAirThroughputStateName("Off")); 
     207                                                break; 
     208                                        } 
     209                                } 
     210 
    100211                        } else { 
    101                                 node.getAirThroughputInterface().setAirThroughputState(StandardAirThroughputStateName.FAN_ON); 
     212                                for(Device device: node.getParent().getResourceCharacteristic().getDevices()){ 
     213                                        if(device.getFullName().equals(Node_Fan_Mapping.getNode_fan().get(node.getFullName()))){ 
     214                                                device.getAirThroughputInterface().setAirThroughputState(new UserAirThroughputStateName("On")); 
     215                                                break; 
     216                                        } 
     217                                } 
    102218                        } 
    103219                } 
Note: See TracChangeset for help on using the changeset viewer.