Changeset 1247 for DCWoRMS/branches


Ignore:
Timestamp:
11/28/13 10:54:54 (11 years ago)
Author:
wojtekp
Message:
 
Location:
DCWoRMS/branches/coolemall/src
Files:
2 deleted
84 edited
3 moved

Legend:

Unmodified
Added
Removed

  • DCWoRMS/branches/coolemall/src/example/energy/DataCenterEnergyEstimationPlugin.java

    r1207 r1247  
    11package example.energy; 
    22 
    3 import schedframe.resources.computing.ComputingNode; 
     3import schedframe.resources.computing.Node; 
    44import schedframe.resources.computing.DataCenter; 
    55import schedframe.resources.computing.profiles.energy.EnergyEvent; 
    … …  
    1515                double power = 0; 
    1616                DataCenter dataCenter = (DataCenter)resource; 
    17                 for(ComputingNode cn:dataCenter.getComputingNodes()){ 
     17                for(Node cn:dataCenter.getNodes()){ 
    1818                        PowerUsage powerUsage = cn.getPowerInterface().getRecentPowerUsage(); 
    1919                        power += (powerUsage == null ? 0 : powerUsage.getValue()); 

  • DCWoRMS/branches/coolemall/src/example/energy/NodeEnergyEstimationPlugin.java

    r1207 r1247  
    11package example.energy; 
    22 
    3 import schedframe.resources.computing.ComputingNode; 
     3import schedframe.resources.computing.Node; 
    44import schedframe.resources.computing.Processor; 
    55import schedframe.resources.computing.profiles.energy.EnergyEvent; 
    … …  
    1313                        PhysicalResource resource) { 
    1414                double powerConsumption = 0; 
    15                 ComputingNode node = (ComputingNode) resource; 
     15                Node node = (Node) resource; 
    1616                for(Processor cpu: node.getProcessors()){ 
    1717                        try{ 

  • DCWoRMS/branches/coolemall/src/example/energy/coolemall/CB2EnergyEstimationPlugin.java

    r1207 r1247  
    33 
    44import schedframe.resources.StandardResourceType; 
     5import schedframe.resources.computing.Node; 
    56import schedframe.resources.computing.ComputingResource; 
    67import schedframe.resources.computing.Processor; 
    78import schedframe.resources.computing.coolemall.ComputeBox1; 
    8 import schedframe.resources.computing.coolemall.Node; 
    99import schedframe.resources.computing.coolemall.NodeGroup; 
    1010import schedframe.resources.computing.profiles.energy.EnergyEvent; 

  • DCWoRMS/branches/coolemall/src/example/energy/coolemall/HeatsinkEnergyEstimationPlugin.java

    r1207 r1247  
    11package example.energy.coolemall; 
    22 
    3 import schedframe.resources.computing.ComputingNode; 
     3import schedframe.resources.computing.Node; 
    44import schedframe.resources.computing.Processor; 
    55import schedframe.resources.computing.profiles.energy.EnergyEvent; 
    … …  
    1616                double powerConsumption = 0; 
    1717                Device device = (Device) resource; 
    18                 ComputingNode cn = (ComputingNode) device.getComputingResource(); 
     18                Node cn = (Node) device.getComputingResource(); 
    1919                for(Processor proc : cn.getProcessors()){ 
    2020                        powerConsumption = powerConsumption + proc.getPowerInterface().getRecentPowerUsage().getValue(); 

  • DCWoRMS/branches/coolemall/src/example/energy/coolemall/NodeEnergyEstimationPlugin.java

    r1207 r1247  
    11package example.energy.coolemall; 
    22 
     3import schedframe.resources.computing.Node; 
    34import schedframe.resources.computing.Processor; 
    4 import schedframe.resources.computing.coolemall.Node; 
    55import schedframe.resources.computing.profiles.energy.EnergyEvent; 
    66import schedframe.resources.computing.profiles.energy.power.StandardPowerStateName; 

  • DCWoRMS/branches/coolemall/src/example/energy/coolemall/NodeGroupEnergyEstimationPlugin.java

    r1207 r1247  
    11package example.energy.coolemall; 
    22 
    3 import schedframe.resources.computing.coolemall.Node; 
     3import schedframe.resources.computing.Node; 
    44import schedframe.resources.computing.coolemall.NodeGroup; 
    55import schedframe.resources.computing.profiles.energy.EnergyEvent; 

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

    r1207 r1247  
    1212import schedframe.resources.ResourceStatus; 
    1313import schedframe.resources.StandardResourceType; 
    14 import schedframe.resources.computing.ComputingNode; 
     14import schedframe.resources.computing.Node; 
    1515import schedframe.resources.computing.ComputingResource; 
    1616import schedframe.resources.computing.Processor; 
    … …  
    8181 
    8282                Map<ResourceUnitName, ResourceUnit> map = new HashMap<ResourceUnitName, ResourceUnit>(); 
    83                 List<ComputingNode> nodes = resourceManager.getComputingNodes(); 
    84                 for (ComputingNode node : nodes) { 
     83                List<Node> nodes = resourceManager.getNodes(); 
     84                for (Node node : nodes) { 
    8585                        int cpuRequest; 
    8686                        try { 

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

    r1207 r1247  
    1212import schedframe.events.scheduling.SchedulingEvent; 
    1313import schedframe.resources.ResourceStatus; 
    14 import schedframe.resources.computing.ComputingNode; 
     14import schedframe.resources.computing.Node; 
    1515import schedframe.resources.computing.ComputingResource; 
    1616import schedframe.resources.units.Memory; 
    … …  
    7474        private Map<ResourceUnitName, ResourceUnit> chooseResourcesForExecution(ClusterResourceManager resourceManager, TaskInterface<?> task) throws NoSuchFieldException { 
    7575 
    76                 List<ComputingNode> nodes = resourceManager.getComputingNodes(); 
     76                List<Node> nodes = resourceManager.getNodes(); 
    7777                nodes = findSuitableNodes(task, nodes); 
    78                 Collections.sort(nodes, new Comparator<ComputingNode>(){ 
    79                     public int compare(ComputingNode node1, ComputingNode node2){    
     78                Collections.sort(nodes, new Comparator<Node>(){ 
     79                    public int compare(Node node1, Node node2){    
    8080                        return node1.getResourceCharacteristic().getParameters().get("category").get(0).getContent().compareTo(node2.getResourceCharacteristic().getParameters().get("category").get(0).getContent()); 
    8181                    } 
    … …  
    8383                if(nodes.size() > 0) 
    8484                { 
    85                         ComputingNode node = nodes.get(0); 
     85                        Node node = nodes.get(0); 
    8686                        Map<ResourceUnitName, ResourceUnit> map = new HashMap<ResourceUnitName, ResourceUnit>(); 
    8787                        List<ComputingResource> choosenResources =  new ArrayList<ComputingResource>(); 
    … …  
    117117        } 
    118118         
    119         private List<ComputingNode> findSuitableNodes(TaskInterface<?> task, List<ComputingNode> nodes) throws NoSuchFieldException{ 
     119        private List<Node> findSuitableNodes(TaskInterface<?> task, List<Node> nodes) throws NoSuchFieldException{ 
    120120                int cpuRequest; 
    121121                try { 
    … …  
    130130                        memoryRequest = 0; 
    131131                } 
    132                 List<ComputingNode> suitableNodes = new ArrayList<ComputingNode>(); 
    133                 for(ComputingNode node: nodes){ 
     132                List<Node> suitableNodes = new ArrayList<Node>(); 
     133                for(Node node: nodes){ 
    134134                        if(node.getFreeProcessorsNumber() >= cpuRequest && node.getFreeMemory() >= memoryRequest){ 
    135135                                suitableNodes.add(node); 

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

    r1207 r1247  
    99import schedframe.events.scheduling.SchedulingEvent; 
    1010import schedframe.resources.StandardResourceType; 
    11 import schedframe.resources.computing.ComputingNode; 
     11import schedframe.resources.computing.Node; 
    1212import schedframe.resources.computing.profiles.energy.airthroughput.StandardAirThroughputStateName; 
    1313import schedframe.resources.computing.profiles.energy.airthroughput.UserAirThroughputStateName; 
    … …  
    4646                        // BaseLocalSchedulingPlugin.placeJobsInQueues() method) 
    4747                        TaskQueue q = queues.get(0); 
    48                         List<ComputingNode> notSelectedNodes = resourceManager.getComputingNodes(); 
     48                        List<Node> notSelectedNodes = resourceManager.getNodes(); 
    4949                        // check all tasks in queue 
    5050                        for (int i = 0; i < q.size(); i++) { 
    … …  
    5353                                if (task.getStatus() == DCWormsTags.READY) { 
    5454 
    55                                         ComputingNode node = chooseRandomProvider(resourceManager, task); 
     55                                        Node node = chooseRandomProvider(resourceManager, task); 
    5656                                        if (node != null) { 
    5757                                                //if there are two or more tasks ( running on the given node then 
    … …  
    8383        } 
    8484 
    85         private ComputingNode chooseRandomProvider(ClusterResourceManager resourceManager, TaskInterface<?> task) { 
    86                 List<ComputingNode> nodes = filterNodes(resourceManager.getComputingNodes(), task); 
     85        private Node chooseRandomProvider(ClusterResourceManager resourceManager, TaskInterface<?> task) { 
     86                List<Node> nodes = filterNodes(resourceManager.getNodes(), task); 
    8787                return randomNode(nodes); 
    8888        } 
    8989         
    90         private List<ComputingNode> filterNodes(List<ComputingNode> nodes, TaskInterface<?> task){ 
    91                 List<ComputingNode> filteredNodes = new ArrayList<ComputingNode>(); 
    92                 for (ComputingNode node : nodes) { 
     90        private List<Node> filterNodes(List<Node> nodes, TaskInterface<?> task){ 
     91                List<Node> filteredNodes = new ArrayList<Node>(); 
     92                for (Node node : nodes) { 
    9393                        int cpuRequest; 
    9494                        try { 
    … …  
    106106        } 
    107107         
    108         private ComputingNode randomNode(List<ComputingNode> nodes){ 
     108        private Node randomNode(List<Node> nodes){ 
    109109                return nodes.get(rand.nextInt(nodes.size())); 
    110110        } 
    111111         
    112         private void adjustOtherFans(List<ComputingNode> nodes){ 
    113                 for(ComputingNode node : nodes){ 
     112        private void adjustOtherFans(List<Node> nodes){ 
     113                for(Node node : nodes){ 
    114114                        List<Device> devices = node.getResourceCharacteristic().getDevices(); 
    115115                        if(node.getFreeProcessorsNumber() == node.getProcessorsNumber()){ 

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

    r1207 r1247  
    1212import schedframe.events.scheduling.SchedulingEvent; 
    1313import schedframe.resources.ResourceStatus; 
    14 import schedframe.resources.computing.ComputingNode; 
     14import schedframe.resources.computing.Node; 
    1515import schedframe.resources.computing.ComputingResource; 
    1616import schedframe.resources.computing.profiles.energy.power.StandardPowerStateName; 
    … …  
    5454                                                addToSchedulingPlan(plan, task, choosenResources); 
    5555                                        } else { 
    56                                                 if(harnessIdleNodesToWork(task, resourceManager.getComputingNodes())) 
     56                                                if(harnessIdleNodesToWork(task, resourceManager.getNodes())) 
    5757                                                        i--; 
    5858                                        } 
    5959                                } 
    6060                        } 
    61                         turnOffIdleNodes(resourceManager.getComputingNodes()); 
     61                        turnOffIdleNodes(resourceManager.getNodes()); 
    6262                        break; 
    6363                } 
    … …  
    6767        private Map<ResourceUnitName, ResourceUnit> chooseResourcesForExecution(ClusterResourceManager resourceManager, TaskInterface<?> task) { 
    6868 
    69                 List<ComputingNode> nodes = resourceManager.getComputingNodes(); 
     69                List<Node> nodes = resourceManager.getNodes(); 
    7070                nodes = findSuitableNodes(task, nodes); 
    71                 Collections.sort(nodes, new Comparator<ComputingNode>(){ 
    72                     public int compare(ComputingNode node1, ComputingNode node2){     
     71                Collections.sort(nodes, new Comparator<Node>(){ 
     72                    public int compare(Node node1, Node node2){     
    7373                        return node1.getResourceCharacteristic().getParameters().get("category").get(0).getContent().compareTo(node2.getResourceCharacteristic().getParameters().get("category").get(0).getContent()); 
    7474                    } 
    … …  
    9898        } 
    9999         
    100         private List<ComputingNode> findSuitableNodes(TaskInterface<?> task, List<ComputingNode> nodes){ 
     100        private List<Node> findSuitableNodes(TaskInterface<?> task, List<Node> nodes){ 
    101101                int cpuRequest; 
    102102                try { 
    … …  
    105105                        cpuRequest = 1; 
    106106                } 
    107                 List<ComputingNode> avNodes = new ArrayList<ComputingNode>(); 
    108                 for(ComputingNode node: nodes){ 
     107                List<Node> avNodes = new ArrayList<Node>(); 
     108                for(Node node: nodes){ 
    109109                        if(node.getFreeProcessorsNumber() >= cpuRequest){ 
    110110                                avNodes.add(node); 
    … …  
    114114        } 
    115115 
    116         private void turnOffIdleNodes(List<ComputingNode> nodes){ 
    117                 for(ComputingNode node : nodes){ 
     116        private void turnOffIdleNodes(List<Node> nodes){ 
     117                for(Node node : nodes){ 
    118118                        if(node.getFreeProcessorsNumber() == node.getProcessorsNumber()){ 
    119119                                node.getPowerInterface().setPowerState(StandardPowerStateName.OFF); 
    … …  
    122122        } 
    123123         
    124         private boolean harnessIdleNodesToWork(TaskInterface<?> task, List<ComputingNode> nodes){ 
     124        private boolean harnessIdleNodesToWork(TaskInterface<?> task, List<Node> nodes){ 
    125125                int cpuRequest; 
    126126                try { 
    … …  
    129129                        cpuRequest = 1; 
    130130                } 
    131                 Collections.sort(nodes, new Comparator<ComputingNode>(){ 
    132                     public int compare(ComputingNode node1, ComputingNode node2){     
     131                Collections.sort(nodes, new Comparator<Node>(){ 
     132                    public int compare(Node node1, Node node2){     
    133133                        return node1.getResourceCharacteristic().getParameters().get("category").get(0).getContent().compareTo(node2.getResourceCharacteristic().getParameters().get("category").get(0).getContent()); 
    134134                    } 
    135135                }); 
    136136                for (int i = 0; i < nodes.size() && cpuRequest > 0; i++) { 
    137                         ComputingNode node = nodes.get(i); 
     137                        Node node = nodes.get(i); 
    138138                        if(node.getPowerInterface().getPowerState() == StandardPowerStateName.OFF){ 
    139139                                node.getPowerInterface().setPowerState(StandardPowerStateName.ON); 

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

    r1207 r1247  
    77 
    88import schedframe.events.scheduling.SchedulingEvent; 
    9 import schedframe.resources.computing.ComputingNode; 
     9import schedframe.resources.computing.Node; 
    1010import schedframe.scheduling.manager.resources.ClusterResourceManager; 
    1111import schedframe.scheduling.manager.resources.ResourceManager; 
    … …  
    5959 
    6060        private String chooseRandomProvider(ClusterResourceManager resourceManager) { 
    61                 List<ComputingNode> nodes = resourceManager.getComputingNodes(); 
     61                List<Node> nodes = resourceManager.getNodes(); 
    6262                int nodeIdx = rand.nextInt(nodes.size()); 
    6363                return nodes.get(nodeIdx).getFullName(); 

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

    r1207 r1247  
    1212import schedframe.resources.ResourceStatus; 
    1313import schedframe.resources.StandardResourceType; 
     14import schedframe.resources.computing.Node; 
    1415import schedframe.resources.computing.ComputingResource; 
    1516import schedframe.resources.computing.Core; 
    1617import schedframe.resources.computing.Processor; 
    17 import schedframe.resources.computing.coolemall.Node; 
    1818import schedframe.resources.computing.profiles.energy.airthroughput.UserAirThroughputStateName; 
    1919import schedframe.resources.computing.profiles.energy.power.StandardPowerStateName; 

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

    r1207 r1247  
    1212import schedframe.resources.ResourceStatus; 
    1313import schedframe.resources.StandardResourceType; 
     14import schedframe.resources.computing.Node; 
    1415import schedframe.resources.computing.ComputingResource; 
    1516import schedframe.resources.computing.Core; 
    1617import schedframe.resources.computing.Processor; 
    17 import schedframe.resources.computing.coolemall.Node; 
    1818import schedframe.resources.computing.profiles.energy.airthroughput.UserAirThroughputStateName; 
    1919import schedframe.resources.computing.profiles.energy.power.StandardPowerStateName; 

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

    r1207 r1247  
    1212import schedframe.resources.ResourceStatus; 
    1313import schedframe.resources.StandardResourceType; 
     14import schedframe.resources.computing.Node; 
    1415import schedframe.resources.computing.ComputingResource; 
    1516import schedframe.resources.computing.Core; 
    16 import schedframe.resources.computing.coolemall.Node; 
    1717import schedframe.resources.units.ProcessingElements; 
    1818import schedframe.resources.units.ResourceUnit; 

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

    r1207 r1247  
    66import schedframe.exceptions.ResourceException; 
    77import schedframe.resources.StandardResourceType; 
     8import schedframe.resources.computing.Node; 
    89import schedframe.resources.computing.ComputingResource; 
    9 import schedframe.resources.computing.coolemall.Node; 
    1010import schedframe.scheduling.manager.resources.ClusterResourceManager; 
    1111import schedframe.scheduling.manager.resources.ResourceManager; 

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

    r1207 r1247  
    1111import schedframe.resources.ResourceStatus; 
    1212import schedframe.resources.StandardResourceType; 
     13import schedframe.resources.computing.Node; 
    1314import schedframe.resources.computing.ComputingResource; 
    1415import schedframe.resources.computing.Core; 
    15 import schedframe.resources.computing.coolemall.Node; 
    1616import schedframe.resources.units.ProcessingElements; 
    1717import schedframe.resources.units.ResourceUnit; 

  • DCWoRMS/branches/coolemall/src/example/localplugin/coolemall/computebox2/CB2_FCFS_Consolidation_NodePowMan_SP.java

    r1207 r1247  
    1212import schedframe.resources.ResourceStatus; 
    1313import schedframe.resources.StandardResourceType; 
     14import schedframe.resources.computing.Node; 
    1415import schedframe.resources.computing.ComputingResource; 
    1516import schedframe.resources.computing.Core; 
    1617import schedframe.resources.computing.Processor; 
    17 import schedframe.resources.computing.coolemall.Node; 
    1818import schedframe.resources.computing.profiles.energy.airthroughput.UserAirThroughputStateName; 
    1919import schedframe.resources.computing.profiles.energy.power.StandardPowerStateName; 

  • DCWoRMS/branches/coolemall/src/example/localplugin/coolemall/computebox2/CB2_FCFS_Consolidation_SP.java

    r1207 r1247  
    1212import schedframe.resources.ResourceStatus; 
    1313import schedframe.resources.StandardResourceType; 
     14import schedframe.resources.computing.Node; 
    1415import schedframe.resources.computing.ComputingResource; 
    1516import schedframe.resources.computing.Core; 
    16 import schedframe.resources.computing.coolemall.Node; 
    1717import schedframe.resources.units.ProcessingElements; 
    1818import schedframe.resources.units.ResourceUnit; 

  • DCWoRMS/branches/coolemall/src/example/localplugin/coolemall/computebox2/CB2_FCFS_LoadBalancing_SP.java

    r1207 r1247  
    66import schedframe.exceptions.ResourceException; 
    77import schedframe.resources.StandardResourceType; 
     8import schedframe.resources.computing.Node; 
    89import schedframe.resources.computing.ComputingResource; 
    9 import schedframe.resources.computing.coolemall.Node; 
    1010import schedframe.scheduling.manager.resources.ClusterResourceManager; 
    1111import schedframe.scheduling.manager.resources.ResourceManager; 

  • DCWoRMS/branches/coolemall/src/example/localplugin/coolemall/computebox2/CB2_FCFS_Random_SP.java

    r1207 r1247  
    1010import schedframe.exceptions.ResourceException; 
    1111import schedframe.resources.StandardResourceType; 
     12import schedframe.resources.computing.Node; 
    1213import schedframe.resources.computing.ComputingResource; 
    1314import schedframe.resources.computing.Processor; 
    14 import schedframe.resources.computing.coolemall.Node; 
    1515import schedframe.resources.units.ProcessingElements; 
    1616import schedframe.resources.units.ResourceUnit; 

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

    r1207 r1247  
    1212import schedframe.resources.ResourceStatus; 
    1313import schedframe.resources.StandardResourceType; 
     14import schedframe.resources.computing.Node; 
    1415import schedframe.resources.computing.ComputingResource; 
    1516import schedframe.resources.computing.Processor; 
    16 import schedframe.resources.computing.coolemall.Node; 
    1717import schedframe.resources.computing.profiles.energy.power.StandardPowerStateName; 
    1818import schedframe.resources.units.Memory; 

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

    r1207 r1247  
    66import schedframe.exceptions.ResourceException; 
    77import schedframe.resources.StandardResourceType; 
     8import schedframe.resources.computing.Node; 
    89import schedframe.resources.computing.ComputingResource; 
    9 import schedframe.resources.computing.coolemall.Node; 
    1010import schedframe.scheduling.manager.resources.ClusterResourceManager; 
    1111import schedframe.scheduling.manager.resources.ResourceManager; 

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

    r1207 r1247  
    1111import schedframe.resources.ResourceStatus; 
    1212import schedframe.resources.StandardResourceType; 
    13 import schedframe.resources.computing.ComputingNode; 
     13import schedframe.resources.computing.Node; 
    1414import schedframe.resources.computing.ComputingResource; 
    1515import schedframe.resources.computing.Core; 
    … …  
    5757                        TaskQueue q = queues.get(0); 
    5858                         
    59                         List<ComputingNode> notSelectedNodes = null; 
     59                        List<Node> notSelectedNodes = null; 
    6060                        try { 
    61                                 notSelectedNodes = (List<ComputingNode>) resourceManager.getResourcesOfType(StandardResourceType.Node); 
     61                                notSelectedNodes = (List<Node>) resourceManager.getResourcesOfType(StandardResourceType.Node); 
    6262                        } catch (ResourceException e) { 
    6363                                // TODO Auto-generated catch block 
    … …  
    8888 
    8989        @SuppressWarnings("unchecked") 
    90         private ComputingNode chooseRandomProvider(ClusterResourceManager resourceManager) { 
    91                 List<ComputingNode> nodes = null; 
     90        private Node chooseRandomProvider(ClusterResourceManager resourceManager) { 
     91                List<Node> nodes = null; 
    9292                try { 
    93                         nodes = (List<ComputingNode>) resourceManager.getResourcesOfType(StandardResourceType.Node); 
     93                        nodes = (List<Node>) resourceManager.getResourcesOfType(StandardResourceType.Node); 
    9494                } catch (ResourceException e) { 
    9595                        // TODO Auto-generated catch block 
    … …  
    101101        } 
    102102 
    103         private List<ComputingNode> filterNodes(List<ComputingNode> nodes){ 
    104                 List<ComputingNode> filteredNodes = new ArrayList<ComputingNode>(); 
    105                 for (ComputingNode node : nodes) { 
     103        private List<Node> filterNodes(List<Node> nodes){ 
     104                List<Node> filteredNodes = new ArrayList<Node>(); 
     105                for (Node node : nodes) { 
    106106                        if(node.getFreeProcessors().size() > 0) 
    107107                                filteredNodes.add(node); 
    … …  
    116116                Map<ResourceUnitName, ResourceUnit> map = new HashMap<ResourceUnitName, ResourceUnit>(); 
    117117                 
    118                 List<ComputingNode> nodes = null; 
     118                List<Node> nodes = null; 
    119119                try { 
    120                         nodes = (List<ComputingNode>) resourceManager.getResourcesOfType(StandardResourceType.Node); 
     120                        nodes = (List<Node>) resourceManager.getResourcesOfType(StandardResourceType.Node); 
    121121                } catch (ResourceException e1) { 
    122122                        // TODO Auto-generated catch block 
    123123                        e1.printStackTrace(); 
    124124                } 
    125                 List<ComputingNode> avNodes = filterNodes(nodes, task); 
     125                List<Node> avNodes = filterNodes(nodes, task); 
    126126                if(avNodes.size() == 0) 
    127127                        return null; 
    128                 ComputingNode node = randomNode(avNodes); 
     128                Node node = randomNode(avNodes); 
    129129 
    130130                int cpuRequest; 
    … …  
    158158        } 
    159159         
    160         private List<ComputingNode> filterNodes(List<ComputingNode> nodes, TaskInterface<?> task){ 
    161                 List<ComputingNode> filteredNodes = new ArrayList<ComputingNode>(); 
    162                 for (ComputingNode node : nodes) { 
     160        private List<Node> filterNodes(List<Node> nodes, TaskInterface<?> task){ 
     161                List<Node> filteredNodes = new ArrayList<Node>(); 
     162                for (Node node : nodes) { 
    163163                        int cpuRequest; 
    164164                        try { 
    … …  
    194194        } 
    195195         
    196         private ComputingNode randomNode(List<ComputingNode> nodes){ 
     196        private Node randomNode(List<Node> nodes){ 
    197197                return nodes.get(rand.nextInt(nodes.size())); 
    198198        } 
    199199         
    200         private void adjustOtherFans(List<ComputingNode> nodes) { 
    201                 for (ComputingNode node : nodes) { 
     200        private void adjustOtherFans(List<Node> nodes) { 
     201                for (Node node : nodes) { 
    202202                         
    203203                        if (node.getProcessors().size() == node.getFreeProcessorsNumber()) { 

  • DCWoRMS/branches/coolemall/src/schedframe/resources/CoolEmAllResourceFactory.java

    r1207 r1247  
    11package schedframe.resources; 
    22 
     3import schedframe.resources.computing.Node; 
    34import schedframe.resources.computing.ComputingResource; 
    45import schedframe.resources.computing.Core; 
    … …  
    78import schedframe.resources.computing.ResourceFactory; 
    89import schedframe.resources.computing.coolemall.ComputeBox1; 
    9 import schedframe.resources.computing.coolemall.Node; 
    1010import schedframe.resources.computing.coolemall.NodeGroup; 
    1111import schedframe.resources.computing.description.ComputingResourceDescription; 

  • DCWoRMS/branches/coolemall/src/schedframe/resources/computing/Core.java

    r1207 r1247  
    2828        } 
    2929         
    30         public ComputingNode getNode(){ 
     30        public Node getNode(){ 
    3131                ComputingResource compRes = parent; 
    3232                while(compRes != null && !compRes.getType().equals(StandardResourceType.Node)){ 
    3333                        compRes = compRes.getParent(); 
    3434                } 
    35                 ComputingNode compNode = null; 
     35                Node compNode = null; 
    3636                try{ 
    37                         compNode = (ComputingNode)compRes; 
     37                        compNode = (Node)compRes; 
    3838                } catch(ClassCastException e) { 
    3939                } 

  • DCWoRMS/branches/coolemall/src/schedframe/resources/computing/DataCenter.java

    r1207 r1247  
    55import schedframe.resources.StandardResourceType; 
    66import schedframe.resources.computing.description.ComputingResourceDescription; 
    7 import schedframe.resources.computing.profiles.energy.EnergyExtension; 
    8 import schedframe.resources.computing.profiles.energy.power.PowerInterfaceFactory; 
    9 import schedframe.resources.computing.profiles.energy.power.ui.PowerInterface; 
    107 
    118public class DataCenter extends ComputingResource{ 
    … …  
    1916         
    2017        @SuppressWarnings("unchecked") 
    21         public List<ComputingNode> getComputingNodes(){ 
    22                 return (List<ComputingNode>) getDescendantsByType(StandardResourceType.Node); 
     18        public List<Node> getNodes(){ 
     19                return (List<Node>) getDescendantsByType(StandardResourceType.Node); 
    2320        } 
    2421         

  • DCWoRMS/branches/coolemall/src/schedframe/resources/computing/Node.java

    r1207 r1247  
    11package schedframe.resources.computing; 
    22 
     3import java.util.ArrayList; 
    34import java.util.List; 
    45import java.util.Properties; 
    … …  
    910import schedframe.resources.computing.extensions.ExtensionType; 
    1011import schedframe.resources.computing.profiles.energy.EnergyExtension; 
    11 import schedframe.resources.computing.profiles.energy.power.ui.ComputingNodePowerInterface; 
    12 import schedframe.resources.computing.properties.ComputingNodePropertiesBuilder; 
     12import schedframe.resources.computing.profiles.energy.power.ui.NodePowerInterface; 
     13import schedframe.resources.computing.properties.NodePropertiesBuilder; 
    1314import schedframe.resources.computing.properties.PropertiesDirector; 
    1415import schedframe.resources.units.Cost; 
    … …  
    1617import schedframe.resources.units.StandardResourceUnitName; 
    1718 
    18 public class ComputingNode extends ComputingResource{ 
     19public class Node extends ComputingResource{ 
    1920         
    2021 
    21         public ComputingNode (ComputingResourceDescription resDesc) { 
     22        public Node (ComputingResourceDescription resDesc) { 
    2223                super(resDesc); 
    2324                 
    … …  
    2930        }        
    3031         
    31         public ComputingNodePowerInterface getPowerInterface(){ 
    32                 ComputingNodePowerInterface powerInterface = null; 
     32        public NodePowerInterface getPowerInterface(){ 
     33                NodePowerInterface powerInterface = null; 
    3334                if(extensionList.isExtensionAvailable(ExtensionType.ENERGY_EXTENSION)){ 
    3435                        EnergyExtension ee = (EnergyExtension)extensionList.getExtension(ExtensionType.ENERGY_EXTENSION); 
    35                         powerInterface = (ComputingNodePowerInterface)ee.getPowerInterface(); 
     36                        powerInterface = (NodePowerInterface)ee.getPowerInterface(); 
    3637                } 
    3738                return powerInterface; 
    … …  
    4849        } 
    4950 
     51        public List<Core> getCores(){ 
     52                List<Core> cores = new ArrayList<Core>(); 
     53                for(Processor proc: getProcessors()){ 
     54                        cores.addAll(proc.getCores()); 
     55                } 
     56                return cores; 
     57        } 
     58 
     59        public List<Core> getFreeCores(){ 
     60                List<Core> freeCores = new ArrayList<Core>(); 
     61                for(Processor proc: getProcessors()){ 
     62                        freeCores.addAll(proc.getFreeCores()); 
     63                } 
     64                return freeCores; 
     65        } 
     66         
    5067        public int getProcessorsNumber() { 
    5168                return getProcessors().size(); 
    … …  
    88105        public Properties getProperties(){ 
    89106                PropertiesDirector propDirector = new PropertiesDirector(); 
    90                 propDirector.setPropertiesBuilder(new ComputingNodePropertiesBuilder()); 
     107                propDirector.setPropertiesBuilder(new NodePropertiesBuilder()); 
    91108                propDirector.constructProperties(this); 
    92109                return propDirector.getProperties(); 

  • DCWoRMS/branches/coolemall/src/schedframe/resources/computing/Processor.java

    r1207 r1247  
    2525        } 
    2626 
    27         public ComputingNode getNode(){ 
     27        public Node getNode(){ 
    2828                ComputingResource compRes = parent; 
    2929                while(compRes != null && !compRes.getType().equals(StandardResourceType.Node)){ 
    3030                        compRes = compRes.getParent(); 
    3131                } 
    32                 ComputingNode compNode = null; 
     32                Node compNode = null; 
    3333                try{ 
    34                         compNode = (ComputingNode)compRes; 
     34                        compNode = (Node)compRes; 
    3535                } catch(Exception e) { 
    3636                } 

  • DCWoRMS/branches/coolemall/src/schedframe/resources/computing/Rack.java

    r1207 r1247  
    1616 
    1717        @SuppressWarnings("unchecked") 
    18         public List<ComputingNode> getComputingNodes(){ 
    19                 return (List<ComputingNode>) getDescendantsByType(StandardResourceType.Node); 
     18        public List<Node> getNodes(){ 
     19                return (List<Node>) getDescendantsByType(StandardResourceType.Node); 
    2020        } 
    2121         

  • DCWoRMS/branches/coolemall/src/schedframe/resources/computing/StandardResourceFactory.java

    r1207 r1247  
    11package schedframe.resources.computing; 
    22 
    3 import schedframe.resources.CoolEmAllResourceType; 
    43import schedframe.resources.StandardResourceType; 
    54import schedframe.resources.computing.description.ComputingResourceDescription; 
    … …  
    2322                        return new Rack(resDesc); 
    2423                else if (resDesc.getType().equals(StandardResourceType.Node)) 
    25                         return new ComputingNode(resDesc); 
     24                        return new Node(resDesc); 
    2625                else if (resDesc.getType().equals(StandardResourceType.Processor)) 
    2726                        return new Processor(resDesc); 
    … …  
    3029                else 
    3130                        return new ComputingResource(resDesc); 
    32          
    33                 /*switch(resDesc.getType()){ 
    34                         case Grid: return new Grid(resDesc); 
    35                         case DataCenter: return new DataCenter(resDesc); 
    36                         case ComputingNode: return new ComputingNode(resDesc); 
    37                         case Processor: return new Processor(resDesc); 
    38                 default: 
    39                         return new ComputingResource(resDesc); 
    40                 }*/ 
     31 
    4132        } 
    4233 

  • DCWoRMS/branches/coolemall/src/schedframe/resources/computing/coolemall/ComputeBox1.java

    r1207 r1247  
    44 
    55import schedframe.resources.CoolEmAllResourceType; 
    6 import schedframe.resources.StandardResourceType; 
    7 import schedframe.resources.computing.ComputingNode; 
    86import schedframe.resources.computing.Rack; 
    97import schedframe.resources.computing.description.ComputingResourceDescription; 
    … …  
    1917                return (List<NodeGroup>) getDescendantsByType(CoolEmAllResourceType.NodeGroup); 
    2018        } 
    21          
    22         @SuppressWarnings("unchecked") 
    23         public List<ComputingNode> getNodes(){ 
    24                 return (List<ComputingNode>) getDescendantsByType(StandardResourceType.Node); 
    25         } 
    26  
    2719 
    2820} 

  • DCWoRMS/branches/coolemall/src/schedframe/resources/computing/coolemall/NodeGroup.java

    r1207 r1247  
    44 
    55import schedframe.resources.StandardResourceType; 
     6import schedframe.resources.computing.Node; 
    67import schedframe.resources.computing.ComputingResource; 
    78import schedframe.resources.computing.Processor; 

  • DCWoRMS/branches/coolemall/src/schedframe/resources/computing/profiles/energy/power/PowerInterfaceFactory.java

    r1207 r1247  
    1818                        powerInterface = new schedframe.resources.computing.profiles.energy.power.ui.DataCenterPowerInterface((ComputingResource)resource, pp); 
    1919                else if (resource.getType().getName().equals(StandardResourceType.Node.getName())) 
    20                         powerInterface = new schedframe.resources.computing.profiles.energy.power.ui.ComputingNodePowerInterface((ComputingResource)resource, pp); 
     20                        powerInterface = new schedframe.resources.computing.profiles.energy.power.ui.NodePowerInterface((ComputingResource)resource, pp); 
    2121                else if (resource.getType().getName().equals(StandardResourceType.Processor.getName())) 
    2222                        powerInterface = new schedframe.resources.computing.profiles.energy.power.ui.ProcessorPowerInterface((ComputingResource)resource, pp); 

  • DCWoRMS/branches/coolemall/src/schedframe/resources/computing/profiles/energy/power/ui/NodePowerInterface.java

    r1207 r1247  
    33 
    44 
    5 import org.joda.time.DateTime; 
    6  
    7 import schedframe.SimulatedEnvironment; 
    85import schedframe.resources.ResourceStatus; 
    9 import schedframe.resources.computing.ComputingNode; 
    106import schedframe.resources.computing.ComputingResource; 
     7import schedframe.resources.computing.Node; 
    118import schedframe.resources.computing.profiles.energy.EnergyEvent; 
    129import schedframe.resources.computing.profiles.energy.EnergyEventType; 
    … …  
    1512import schedframe.resources.computing.profiles.energy.power.StandardPowerStateName; 
    1613 
    17 public class ComputingNodePowerInterface extends ComputingResourcePowerInterface{ 
     14public class NodePowerInterface extends ComputingResourcePowerInterface{ 
    1815 
    1916        public static long START_TIME = 600000; 
    … …  
    2320 
    2421         
    25         public ComputingNodePowerInterface(ComputingResource resource, PowerProfile pp){ 
     22        public NodePowerInterface(ComputingResource resource, PowerProfile pp){ 
    2623                super(resource, pp); 
    2724                currentPowerState = StandardPowerStateName.ON; 
    … …  
    3229                        return false; 
    3330                currentPowerState = state; 
    34                 ComputingNode computingNode = (ComputingNode) resource; 
     31                Node node = (Node) resource; 
    3532                boolean pePowerStateChangeStatus = false; 
    36                 if(computingNode.getProcessors() != null) { 
    37                         for(ComputingResource child:computingNode.getProcessors()){ 
     33                if(node.getProcessors() != null) { 
     34                        for(ComputingResource child:node.getProcessors()){ 
    3835                                if(child.getPowerInterface() != null){ 
    3936                                        pePowerStateChangeStatus = child.getPowerInterface().setPowerState(state);       
    … …  
    4340                 
    4441                if(!pePowerStateChangeStatus){ 
    45                         computingNode.handleEvent(new EnergyEvent(EnergyEventType.POWER_STATE_CHANGED, computingNode.getFullName())); 
     42                        node.handleEvent(new EnergyEvent(EnergyEventType.POWER_STATE_CHANGED, node.getFullName())); 
    4643                } 
    4744 
    4845                if(state == StandardPowerStateName.OFF){ 
    49                         computingNode.setStatus(ResourceStatus.UNAVAILABLE); 
     46                        node.setStatus(ResourceStatus.UNAVAILABLE); 
    5047                } 
    5148                else if(state == StandardPowerStateName.ON){ 
    52                         computingNode.setStatus(ResourceStatus.FREE); 
     49                        node.setStatus(ResourceStatus.FREE); 
    5350                } 
    54                 //computingNode.handleEvent(new EnergyEvent(EnergyEventType.POWER_STATE_CHANGED, computingNode.getName())); 
     51                //node.handleEvent(new EnergyEvent(EnergyEventType.POWER_STATE_CHANGED, computingNode.getName())); 
    5552                //ResourceController.traceResource(new DateTime().getMillis(), resource.getFullName(), "POWER_STATE_CHANGED", state.getName()); 
    5653                return true; 

  • DCWoRMS/branches/coolemall/src/schedframe/resources/computing/properties/NodePropertiesBuilder.java

    r1053 r1247  
    33import java.util.Properties; 
    44 
    5 import schedframe.resources.computing.ComputingNode; 
     5import schedframe.resources.computing.Node; 
    66import schedframe.resources.computing.ComputingResource; 
    77 
    8 public class ComputingNodePropertiesBuilder implements PropertiesBuilder{ 
     8public class NodePropertiesBuilder implements PropertiesBuilder{ 
    99        protected Properties properties; 
    10         private ComputingNode node; 
     10        private Node node; 
    1111         
    1212        public Properties getProperties() { 
    … …  
    1616        public void createProperties(ComputingResource resource) { 
    1717                this.properties = new Properties(); 
    18                 this.node = (ComputingNode)resource; 
     18                this.node = (Node)resource; 
    1919        } 
    2020 

  • DCWoRMS/branches/coolemall/src/schedframe/resources/devices/DeviceEnergyExtension.java

    r1207 r1247  
    77 
    88import schedframe.events.Event; 
    9 import schedframe.resources.computing.ComputingResource; 
    109import schedframe.resources.computing.extensions.Extension; 
    1110import schedframe.resources.computing.extensions.ExtensionException; 
    … …  
    1413import schedframe.resources.computing.profiles.energy.EnergyEventType; 
    1514import schedframe.resources.computing.profiles.energy.EnergyExtension; 
    16 import schedframe.resources.computing.profiles.energy.EnergyExtension.Builder; 
    1715import schedframe.resources.computing.profiles.energy.airthroughput.AirThroughputInterfaceFactory; 
    1816import schedframe.resources.computing.profiles.energy.airthroughput.AirThroughputProfile; 
    … …  
    114112                        case POWER_STATE_CHANGED: 
    115113                                power = powerProfile.getEnergyEstimationPlugin().estimatePowerConsumption(enEvent, new JobRegistryImpl(resource.getFullName()), resource); 
    116                                 /*if(computingResource instanceof ComputingNode){ 
    117                                         ComputingNode node = (ComputingNode)computingResource; 
    118                                         if(event.getData() instanceof PowerState){ 
    119                                                 PowerState newState = (PowerState)event.getData(); 
    120                                                 if(newState == PowerState.ON) { 
    121                                                         addToPowerUsageHistory(power+node.getPowerInterface().START_COST); 
    122                                                         addToPowerUsageHistory(DateTimeUtils.currentTimeMillis() + node.getPowerInterface().START_TIME, power); 
    123                                                 }else if(newState == PowerState.OFF){ 
    124                                                         addToPowerUsageHistory(power+node.getPowerInterface().SHUTDOWN_COST); 
    125                                                         addToPowerUsageHistory(DateTimeUtils.currentTimeMillis() + node.getPowerInterface().SHUTDOWN_TIME, power); 
    126                                                 } 
    127                                         } 
    128                                 } 
    129                                 else*/  
    130114                                 
    131115                                status = powerProfile.addToPowerUsageHistory(power); 

  • DCWoRMS/branches/coolemall/src/schedframe/scheduling/manager/resources/ClusterResourceManager.java

    r1207 r1247  
    77import schedframe.exceptions.ResourceException; 
    88import schedframe.resources.StandardResourceType; 
    9 import schedframe.resources.computing.ComputingNode; 
     9import schedframe.resources.computing.Node; 
    1010import schedframe.resources.computing.ComputingResource; 
    1111import schedframe.resources.computing.Processor; 
    … …  
    2121 
    2222        @SuppressWarnings("unchecked") 
    23         public List<ComputingNode> getComputingNodes(){ 
     23        public List<Node> getNodes(){ 
    2424                try { 
    25                         return (List<ComputingNode>) getResourcesOfType(StandardResourceType.Node); 
     25                        return (List<Node>) getResourcesOfType(StandardResourceType.Node); 
    2626                } catch (ResourceException e) { 
    27                         return new ArrayList<ComputingNode>(); 
     27                        return new ArrayList<Node>(); 
    2828                } 
    2929        } 
    … …  
    3939 
    4040        @SuppressWarnings("unchecked") 
    41         public List<ComputingNode> getComputingNodes(Properties properties){ 
     41        public List<Node> getNodes(Properties properties){ 
    4242                properties.setProperty("type", StandardResourceType.Node.toString()); 
    43                 return (List<ComputingNode>) filterResources(properties); 
     43                return (List<Node>) filterResources(properties); 
    4444 
    4545        } 

  • DCWoRMS/branches/coolemall/src/schedframe/scheduling/manager/resources/ResourceManagerFactory.java

    r1005 r1247  
    11package schedframe.scheduling.manager.resources; 
    22 
     3import schedframe.resources.StandardResourceType; 
    34import schedframe.scheduling.GridResourceDiscovery; 
    45import schedframe.scheduling.Scheduler; 
    … …  
    1011                ManagedComputingResources managedResource = scheduler.getCompResources(); 
    1112                 
    12                 if(managedResources == null || managedResource.getType().getName().equals("DataCenter")) 
     13                if(managedResources == null || managedResource.getType().getName().equals(StandardResourceType.DataCenter)) 
    1314                        return new GridResourceDiscovery(scheduler); 
    14                 else if (managedResource.getType().getName().equals("Rack")) 
     15                else if (managedResource.getType().getName().equals(StandardResourceType.Rack)) 
    1516                        return new ClusterResourceManager(scheduler.getCompResources(), scheduler.getChildren(), managedResources); 
    16                 else if (managedResource.getType().getName().equals("ComputingNode")) 
     17                else if (managedResource.getType().getName().equals(StandardResourceType.Node)) 
    1718                        return new ClusterResourceManager(scheduler.getCompResources(), scheduler.getChildren(), managedResources); 
    18                 else if (managedResource.getType().getName().equals("Processor")) 
     19                else if (managedResource.getType().getName().equals(StandardResourceType.Processor)) 
    1920                        return new ClusterResourceManager(scheduler.getCompResources(), scheduler.getChildren(), managedResources); 
    2021                else return new ClusterResourceManager(scheduler.getCompResources(), scheduler.getChildren(), managedResources); 

  • DCWoRMS/branches/coolemall/src/simulator/stats/implementation/TaskStats.java

    r1207 r1247  
    77 
    88 
    9 import schedframe.resources.computing.ComputingNode; 
     9import schedframe.resources.computing.Node; 
    1010import schedframe.resources.computing.ComputingResource; 
    1111import schedframe.resources.computing.Core; 
    … …  
    180180                while(it.hasNext()) { 
    181181                        ComputingResource compRes = it.next(); 
    182                         ComputingNode node = null; 
     182                        Node node = null; 
    183183                        if(compRes instanceof Core){ 
    184184                                Core core =(Core) compRes; 
    185                                 node = (ComputingNode)core.getNode(); 
     185                                node = (Node)core.getNode(); 
    186186                        } else if(compRes instanceof Processor){ 
    187187                                Processor proc = (Processor) compRes; 
    188                                 node = (ComputingNode)proc.getNode(); 
    189                         } else if(compRes instanceof ComputingNode){ 
    190                                 node = (ComputingNode)compRes; 
     188                                node = (Node)proc.getNode(); 
     189                        } else if(compRes instanceof Node){ 
     190                                node = (Node)compRes; 
    191191                        } 
    192192                        if(node != null) 

  • DCWoRMS/branches/coolemall/src/test/ariel/FCFSCPUFreqScalingPlugin.java

    r506 r1247  
    1212import schedframe.events.scheduling.TaskRequestedTimeExpiredEvent; 
    1313import schedframe.resources.ResourceStatus; 
    14 import schedframe.resources.computing.ComputingNode; 
     14import schedframe.resources.computing.Node; 
    1515import schedframe.resources.computing.ComputingResource; 
    1616import schedframe.resources.computing.Processor; 

  • DCWoRMS/branches/coolemall/src/test/article/recs/plugins/energy/AmdNodeEEP.java

    r1208 r1247  
    44import java.io.IOException; 
    55 
    6 import schedframe.resources.computing.ComputingNode; 
     6import schedframe.resources.computing.Node; 
    77import schedframe.resources.computing.Processor; 
    88import schedframe.resources.computing.profiles.energy.EnergyEvent; 
    … …  
    1515                        PhysicalResource resource) { 
    1616                double powerConsumption = 0; 
    17                 ComputingNode node = (ComputingNode) resource; 
     17                Node node = (Node) resource; 
    1818                try { 
    1919                        if(jobRegistry.getRunningTasks().size() > 0) { 

  • DCWoRMS/branches/coolemall/src/test/article/recs/plugins/energy/AtomD510NodeEEP.java

    r1208 r1247  
    44import java.io.IOException; 
    55 
    6 import schedframe.resources.computing.ComputingNode; 
     6import schedframe.resources.computing.Node; 
    77import schedframe.resources.computing.Processor; 
    88import schedframe.resources.computing.profiles.energy.EnergyEvent; 
    … …  
    1515                        PhysicalResource resource) { 
    1616                double powerConsumption = 0; 
    17                 ComputingNode node = (ComputingNode) resource; 
     17                Node node = (Node) resource; 
    1818                try { 
    1919                        if(jobRegistry.getRunningTasks().size() > 0) { 

  • DCWoRMS/branches/coolemall/src/test/article/recs/plugins/energy/AtomZ510NodeEEP.java

    r1208 r1247  
    44import java.io.IOException; 
    55 
    6 import schedframe.resources.computing.ComputingNode; 
     6import schedframe.resources.computing.Node; 
    77import schedframe.resources.computing.Processor; 
    88import schedframe.resources.computing.profiles.energy.EnergyEvent; 
    … …  
    1515                        PhysicalResource resource) { 
    1616                double powerConsumption = 0; 
    17                 ComputingNode node = (ComputingNode) resource; 
     17                Node node = (Node) resource; 
    1818                try { 
    1919                        if(jobRegistry.getRunningTasks().size() > 0) { 

  • DCWoRMS/branches/coolemall/src/test/article/recs/plugins/energy/IntelNodeEEP.java

    r1208 r1247  
    44import java.io.IOException; 
    55 
    6 import schedframe.resources.computing.ComputingNode; 
     6import schedframe.resources.computing.Node; 
    77import schedframe.resources.computing.Processor; 
    88import schedframe.resources.computing.profiles.energy.EnergyEvent; 
    … …  
    1515                        PhysicalResource resource) { 
    1616                double powerConsumption = 0; 
    17                 ComputingNode node = (ComputingNode) resource; 
     17                Node node = (Node) resource; 
    1818                 
    1919                try { 

  • DCWoRMS/branches/coolemall/src/test/article/recs/plugins/energy/RecsNodeBaseEEP.java

    r734 r1247  
    88import java.util.ResourceBundle; 
    99 
    10 import schedframe.resources.computing.ComputingNode; 
     10import schedframe.resources.computing.Node; 
    1111import schedframe.resources.computing.Core; 
    1212import schedframe.resources.computing.Processor; 
    … …  
    4747                 
    4848                ProcessingElements pe = (ProcessingElements) peUnit; 
    49                 if(pe.get(0) instanceof ComputingNode) 
    50                         return ((ComputingNode)pe.get(0)).getCategory(); 
     49                if(pe.get(0) instanceof Node) 
     50                        return ((Node)pe.get(0)).getCategory(); 
    5151                Core core = (Core)pe.get(0); 
    5252                return core.getParent().getParent().getCategory(); 
    … …  
    5555        private int getFrequency(PEUnit peUnit){ 
    5656                ProcessingElements pe = (ProcessingElements) peUnit; 
    57                 if(pe.get(0) instanceof ComputingNode) 
    58                         return Double.valueOf(((ComputingNode)pe.get(0)).getProcessors().get(0).getPowerInterface().getFrequency()).intValue(); 
     57                if(pe.get(0) instanceof Node) 
     58                        return Double.valueOf(((Node)pe.get(0)).getProcessors().get(0).getPowerInterface().getFrequency()).intValue(); 
    5959                Core core = (Core)pe.get(0); 
    6060                Processor proc = (Processor) core.getParent(); 

  • DCWoRMS/branches/coolemall/src/test/article/recs/plugins/energy/RecsNodeModelEEP.java

    r1208 r1247  
    1111import java.util.ResourceBundle; 
    1212 
    13 import schedframe.resources.computing.ComputingNode; 
     13import schedframe.resources.computing.Node; 
    1414import schedframe.resources.computing.Core; 
    1515import schedframe.resources.computing.Processor; 
    … …  
    4545                        PhysicalResource resource) { 
    4646                double powerConsumption = 0; 
    47                 ComputingNode node = (ComputingNode) resource; 
     47                Node node = (Node) resource; 
    4848                 
    4949                try { 
    … …  
    9292                 
    9393                ProcessingElements pe = (ProcessingElements) peUnit; 
    94                 if(pe.get(0) instanceof ComputingNode) 
    95                         return ((ComputingNode)pe.get(0)).getCategory(); 
     94                if(pe.get(0) instanceof Node) 
     95                        return ((Node)pe.get(0)).getCategory(); 
    9696                if(pe.get(0) instanceof Processor) 
    9797                        return ((Processor)pe.get(0)).getParent().getCategory(); 
    … …  
    102102        private int getFrequency(PEUnit peUnit){ 
    103103                ProcessingElements pe = (ProcessingElements) peUnit; 
    104                 if(pe.get(0) instanceof ComputingNode) 
    105                         return Double.valueOf(((ComputingNode)pe.get(0)).getProcessors().get(0).getPowerInterface().getFrequency()).intValue(); 
     104                if(pe.get(0) instanceof Node) 
     105                        return Double.valueOf(((Node)pe.get(0)).getProcessors().get(0).getPowerInterface().getFrequency()).intValue(); 
    106106                if(pe.get(0) instanceof Processor) 
    107107                        return Double.valueOf(((Processor)pe.get(0)).getPowerInterface().getFrequency()).intValue(); 

  • DCWoRMS/branches/coolemall/src/test/article/recs/plugins/scheduling/RecsExclusivenessDFSSP.java

    r734 r1247  
    1414import schedframe.events.scheduling.SchedulingEvent; 
    1515import schedframe.resources.ResourceStatus; 
    16 import schedframe.resources.computing.ComputingNode; 
     16import schedframe.resources.computing.Node; 
    1717import schedframe.resources.computing.ComputingResource; 
    1818import schedframe.resources.computing.Core; 
    … …  
    7575                Map<ResourceUnitName, ResourceUnit> map = new HashMap<ResourceUnitName, ResourceUnit>(); 
    7676                 
    77                 List<ComputingNode> nodes = resourceManager.getComputingNodes(); 
    78                 List<ComputingNode> avNodes = filterNodes(nodes, task); 
     77                List<Node> nodes = resourceManager.getNodes(); 
     78                List<Node> avNodes = filterNodes(nodes, task); 
    7979                if(avNodes.size() == 0) 
    8080                        return null; 
    81                 ComputingNode node = randomNode(avNodes); 
     81                Node node = randomNode(avNodes); 
    8282 
    8383                int cpuRequest; 
    … …  
    111111        } 
    112112         
    113         private List<ComputingNode> filterNodes(List<ComputingNode> nodes, TaskInterface<?> task){ 
    114                 List<ComputingNode> filteredNodes = new ArrayList<ComputingNode>(); 
    115                 for (ComputingNode node : nodes) { 
     113        private List<Node> filterNodes(List<Node> nodes, TaskInterface<?> task){ 
     114                List<Node> filteredNodes = new ArrayList<Node>(); 
     115                for (Node node : nodes) { 
    116116                        int cpuRequest; 
    117117                        try { 
    … …  
    154154        } 
    155155         
    156         private ComputingNode randomNode(List<ComputingNode> nodes){ 
     156        private Node randomNode(List<Node> nodes){ 
    157157                return nodes.get(rand.nextInt(nodes.size())); 
    158158        } 

  • DCWoRMS/branches/coolemall/src/test/article/recs/plugins/scheduling/RecsExclusivenessEnOptDFSSP.java

    r1208 r1247  
    1818import schedframe.events.scheduling.SchedulingEvent; 
    1919import schedframe.resources.ResourceStatus; 
    20 import schedframe.resources.computing.ComputingNode; 
     20import schedframe.resources.computing.Node; 
    2121import schedframe.resources.computing.ComputingResource; 
    2222import schedframe.resources.computing.Core; 
    … …  
    8484 
    8585                Map<ResourceUnitName, ResourceUnit> map; 
    86                 List<ComputingNode> nodes = resourceManager.getComputingNodes(); 
     86                List<Node> nodes = resourceManager.getNodes(); 
    8787                Collections.sort(nodes, new EnergyComparator(task)); 
    8888                //System.out.println("*****"); 
    89                 for (ComputingNode node : nodes) { 
     89                for (Node node : nodes) { 
    9090                        //System.out.println(node.getCategory()); 
    9191                        int cpuRequest; 
    … …  
    152152 
    153153         
    154         protected String createQuery(TaskInterface<?> task, ComputingNode node) { 
     154        protected String createQuery(TaskInterface<?> task, Node node) { 
    155155                String query; 
    156156                query = getApplicationType(task) + "." + getNodeCategory(node) + "." + getFrequency(node) + "." + getCoreCnt(task); 
    … …  
    181181                return timeBundle; 
    182182        } 
    183         class EnergyComparator implements Comparator<ComputingNode>{ 
     183        class EnergyComparator implements Comparator<Node>{ 
    184184                private TaskInterface<?> task; 
    185185                 
    … …  
    188188                } 
    189189                 
    190             public int compare(ComputingNode node1, ComputingNode node2){     
     190            public int compare(Node node1, Node node2){     
    191191                double node1EU = Double.MAX_VALUE; 
    192192                double node2EU = Double.MAX_VALUE; 

  • DCWoRMS/branches/coolemall/src/test/article/recs/plugins/scheduling/RecsExclusivenessEnOptNodePowManSP.java

    r1197 r1247  
    1818import schedframe.events.scheduling.SchedulingEvent; 
    1919import schedframe.resources.ResourceStatus; 
    20 import schedframe.resources.computing.ComputingNode; 
     20import schedframe.resources.computing.Node; 
    2121import schedframe.resources.computing.ComputingResource; 
    2222import schedframe.resources.computing.Core; 
    … …  
    7575                                } 
    7676                        } 
    77                         turnOffIdleNodes(resourceManager.getComputingNodes()); 
     77                        turnOffIdleNodes(resourceManager.getNodes()); 
    7878                        break; 
    7979                } 
    … …  
    8585 
    8686                Map<ResourceUnitName, ResourceUnit> map; 
    87                 List<ComputingNode> nodes = resourceManager.getComputingNodes(); 
     87                List<Node> nodes = resourceManager.getNodes(); 
    8888                Collections.sort(nodes, new EnergyComparator(task)); 
    89                 for (ComputingNode node : nodes) { 
     89                for (Node node : nodes) { 
    9090                        int cpuRequest; 
    9191                        try { 
    … …  
    155155 
    156156         
    157         protected String createQuery(TaskInterface<?> task, ComputingNode node) { 
     157        protected String createQuery(TaskInterface<?> task, Node node) { 
    158158                String query; 
    159159                query = getApplicationType(task) + "." + getNodeCategory(node) + "." + getFrequency(node) + "." + getCoreCnt(task); 
    … …  
    184184                return timeBundle; 
    185185        } 
    186         class EnergyComparator implements Comparator<ComputingNode>{ 
     186        class EnergyComparator implements Comparator<Node>{ 
    187187                private TaskInterface<?> task; 
    188188                 
    … …  
    191191                } 
    192192                 
    193             public int compare(ComputingNode node1, ComputingNode node2){     
     193            public int compare(Node node1, Node node2){     
    194194                double node1EU = Double.MAX_VALUE; 
    195195                double node2EU = Double.MAX_VALUE; 
    … …  
    221221        } 
    222222         
    223         private void turnOffIdleNodes(List<ComputingNode> nodes){ 
    224                 for(ComputingNode node : nodes){ 
     223        private void turnOffIdleNodes(List<Node> nodes){ 
     224                for(Node node : nodes){ 
    225225                        Processor proc = node.getProcessors().get(0); 
    226226                        int freeCores = 0; 

  • DCWoRMS/branches/coolemall/src/test/article/recs/plugins/scheduling/RecsExclusivenessEnOptSP.java

    r1197 r1247  
    1818import schedframe.events.scheduling.SchedulingEvent; 
    1919import schedframe.resources.ResourceStatus; 
    20 import schedframe.resources.computing.ComputingNode; 
     20import schedframe.resources.computing.Node; 
    2121import schedframe.resources.computing.ComputingResource; 
    2222import schedframe.resources.computing.Core; 
    … …  
    8181 
    8282                Map<ResourceUnitName, ResourceUnit> map; 
    83                 List<ComputingNode> nodes = resourceManager.getComputingNodes(); 
     83                List<Node> nodes = resourceManager.getNodes(); 
    8484                Collections.sort(nodes, new EnergyComparator(task)); 
    8585                //System.out.println("*****"); 
    86                 for (ComputingNode node : nodes) { 
     86                for (Node node : nodes) { 
    8787                        //System.out.println(node.getCategory()); 
    8888                        int cpuRequest; 
    … …  
    149149 
    150150         
    151         protected String createQuery(TaskInterface<?> task, ComputingNode node) { 
     151        protected String createQuery(TaskInterface<?> task, Node node) { 
    152152                String query; 
    153153                query = getApplicationType(task) + "." + getNodeCategory(node) + "." + getFrequency(node) + "." + getCoreCnt(task); 
    … …  
    178178                return timeBundle; 
    179179        } 
    180         class EnergyComparator implements Comparator<ComputingNode>{ 
     180        class EnergyComparator implements Comparator<Node>{ 
    181181                private TaskInterface<?> task; 
    182182                 
    … …  
    185185                } 
    186186                 
    187             public int compare(ComputingNode node1, ComputingNode node2){     
     187            public int compare(Node node1, Node node2){     
    188188                double node1EU = Double.MAX_VALUE; 
    189189                double node2EU = Double.MAX_VALUE; 

  • DCWoRMS/branches/coolemall/src/test/article/recs/plugins/scheduling/RecsExclusivenessRandomNodePowManSP.java

    r734 r1247  
    1414import schedframe.events.scheduling.SchedulingEvent; 
    1515import schedframe.resources.ResourceStatus; 
    16 import schedframe.resources.computing.ComputingNode; 
     16import schedframe.resources.computing.Node; 
    1717import schedframe.resources.computing.ComputingResource; 
    1818import schedframe.resources.computing.Core; 
    … …  
    6464                                } 
    6565                        } 
    66                         turnOffIdleNodes(resourceManager.getComputingNodes()); 
     66                        turnOffIdleNodes(resourceManager.getNodes()); 
    6767                        break; 
    6868                } 
    … …  
    7575                Map<ResourceUnitName, ResourceUnit> map = new HashMap<ResourceUnitName, ResourceUnit>(); 
    7676                 
    77                 List<ComputingNode> nodes = resourceManager.getComputingNodes(); 
    78                 List<ComputingNode> avNodes = filterNodes(nodes, task); 
     77                List<Node> nodes = resourceManager.getNodes(); 
     78                List<Node> avNodes = filterNodes(nodes, task); 
    7979                if(avNodes.size() == 0) 
    8080                        return null; 
    81                 ComputingNode node = randomNode(avNodes); 
     81                Node node = randomNode(avNodes); 
    8282                if(node.getStatus() == ResourceStatus.UNAVAILABLE) { 
    8383                        node.getPowerInterface().setPowerState(StandardPowerStateName.ON); 
    … …  
    113113        } 
    114114         
    115         private List<ComputingNode> filterNodes(List<ComputingNode> nodes, TaskInterface<?> task){ 
    116                 List<ComputingNode> filteredNodes = new ArrayList<ComputingNode>(); 
    117                 for (ComputingNode node : nodes) { 
     115        private List<Node> filterNodes(List<Node> nodes, TaskInterface<?> task){ 
     116                List<Node> filteredNodes = new ArrayList<Node>(); 
     117                for (Node node : nodes) { 
    118118                        int cpuRequest; 
    119119                        try { 
    … …  
    156156        } 
    157157         
    158         private ComputingNode randomNode(List<ComputingNode> nodes){ 
     158        private Node randomNode(List<Node> nodes){ 
    159159                return nodes.get(rand.nextInt(nodes.size())); 
    160160        } 
    161161         
    162         private void turnOffIdleNodes(List<ComputingNode> nodes){ 
    163                 for(ComputingNode node : nodes){ 
     162        private void turnOffIdleNodes(List<Node> nodes){ 
     163                for(Node node : nodes){ 
    164164                        Processor proc = node.getProcessors().get(0); 
    165165                        int freeCores = 0; 

  • DCWoRMS/branches/coolemall/src/test/article/recs/plugins/scheduling/RecsExclusivenessRandomSP.java

    r734 r1247  
    1414import schedframe.events.scheduling.SchedulingEvent; 
    1515import schedframe.resources.ResourceStatus; 
    16 import schedframe.resources.computing.ComputingNode; 
     16import schedframe.resources.computing.Node; 
    1717import schedframe.resources.computing.ComputingResource; 
    1818import schedframe.resources.computing.Core; 
    … …  
    7373                Map<ResourceUnitName, ResourceUnit> map = new HashMap<ResourceUnitName, ResourceUnit>(); 
    7474                 
    75                 List<ComputingNode> nodes = resourceManager.getComputingNodes(); 
    76                 List<ComputingNode> avNodes = filterNodes(nodes, task); 
     75                List<Node> nodes = resourceManager.getNodes(); 
     76                List<Node> avNodes = filterNodes(nodes, task); 
    7777                if(avNodes.size() == 0) 
    7878                        return null; 
    79                 ComputingNode node = randomNode(avNodes); 
     79                Node node = randomNode(avNodes); 
    8080 
    8181                int cpuRequest; 
    … …  
    109109        } 
    110110         
    111         private List<ComputingNode> filterNodes(List<ComputingNode> nodes, TaskInterface<?> task){ 
    112                 List<ComputingNode> filteredNodes = new ArrayList<ComputingNode>(); 
    113                 for (ComputingNode node : nodes) { 
     111        private List<Node> filterNodes(List<Node> nodes, TaskInterface<?> task){ 
     112                List<Node> filteredNodes = new ArrayList<Node>(); 
     113                for (Node node : nodes) { 
    114114                        int cpuRequest; 
    115115                        try { 
    … …  
    152152        } 
    153153         
    154         private ComputingNode randomNode(List<ComputingNode> nodes){ 
     154        private Node randomNode(List<Node> nodes){ 
    155155                return nodes.get(rand.nextInt(nodes.size())); 
    156156        } 

  • DCWoRMS/branches/coolemall/src/test/article/recs/plugins/scheduling/RecsSP.java

    r1197 r1247  
    77import java.util.ResourceBundle; 
    88 
    9 import schedframe.resources.computing.ComputingNode; 
     9import schedframe.resources.computing.Node; 
    1010import schedframe.resources.computing.Processor; 
    1111import schedframe.scheduling.tasks.TaskInterface; 
    … …  
    2727        } 
    2828         
    29         protected String createExecutivenessQuery(TaskInterface<?> task, ComputingNode node) { 
     29        protected String createExecutivenessQuery(TaskInterface<?> task, Node node) { 
    3030                Executable exec = (Executable)task; 
    3131                String query = getApplicationType(exec) + "." + getNodeCategory(node); 
    … …  
    3838        } 
    3939         
    40         protected String getNodeCategory(ComputingNode node){ 
     40        protected String getNodeCategory(Node node){ 
    4141                return node.getCategory(); 
    4242        } 
    … …  
    5252        } 
    5353         
    54         protected int getFrequency(ComputingNode node){ 
     54        protected int getFrequency(Node node){ 
    5555                Processor proc = (Processor) node.getProcessors().get(0); 
    5656                double freq = proc.getPowerInterface().getFrequency(); 

  • DCWoRMS/branches/coolemall/src/test/article/recs/plugins/timeestimation/RecsTimeEstimationPlugin.java

    r734 r1247  
    1010 
    1111import schedframe.events.scheduling.SchedulingEvent; 
    12 import schedframe.resources.computing.ComputingNode; 
     12import schedframe.resources.computing.Node; 
    1313import schedframe.resources.computing.Core; 
    1414import schedframe.resources.computing.Processor; 
    … …  
    7474                 
    7575                ProcessingElements pe = (ProcessingElements) peUnit; 
    76                 if(pe.get(0) instanceof ComputingNode) 
    77                         return ((ComputingNode)pe.get(0)).getCategory(); 
     76                if(pe.get(0) instanceof Node) 
     77                        return ((Node)pe.get(0)).getCategory(); 
    7878                Core core = (Core)pe.get(0); 
    7979                return core.getParent().getParent().getCategory(); 
    … …  
    8282        private int getFrequency(PEUnit peUnit){ 
    8383                ProcessingElements pe = (ProcessingElements) peUnit; 
    84                 if(pe.get(0) instanceof ComputingNode) 
    85                         return Double.valueOf(((ComputingNode)pe.get(0)).getProcessors().get(0).getPowerInterface().getFrequency()).intValue(); 
     84                if(pe.get(0) instanceof Node) 
     85                        return Double.valueOf(((Node)pe.get(0)).getProcessors().get(0).getPowerInterface().getFrequency()).intValue(); 
    8686                Core core = (Core)pe.get(0); 
    8787                Processor proc = (Processor) core.getParent(); 

  • DCWoRMS/branches/coolemall/src/test/article2/recs/plugins/energy/AmdNodeEEP.java

    r1210 r1247  
    44import java.io.IOException; 
    55 
    6 import schedframe.resources.computing.ComputingNode; 
     6import schedframe.resources.computing.Node; 
    77import schedframe.resources.computing.Processor; 
    88import schedframe.resources.computing.profiles.energy.EnergyEvent; 
    … …  
    1515                        PhysicalResource resource) { 
    1616                double powerConsumption = 0; 
    17                 ComputingNode node = (ComputingNode) resource; 
     17                Node node = (Node) resource; 
    1818                try { 
    1919                        if(jobRegistry.getRunningTasks().size() > 0) { 

  • DCWoRMS/branches/coolemall/src/test/article2/recs/plugins/energy/AtomD510NodeEEP.java

    r1210 r1247  
    44import java.io.IOException; 
    55 
    6 import schedframe.resources.computing.ComputingNode; 
     6import schedframe.resources.computing.Node; 
    77import schedframe.resources.computing.Processor; 
    88import schedframe.resources.computing.profiles.energy.EnergyEvent; 
    … …  
    1515                        PhysicalResource resource) { 
    1616                double powerConsumption = 0; 
    17                 ComputingNode node = (ComputingNode) resource; 
     17                Node node = (Node) resource; 
    1818                try { 
    1919                        if(jobRegistry.getRunningTasks().size() > 0) { 

  • DCWoRMS/branches/coolemall/src/test/article2/recs/plugins/energy/DataCenterEnergyEstimationPlugin.java

    r1210 r1247  
    11package test.article2.recs.plugins.energy; 
    22 
    3 import schedframe.resources.computing.ComputingNode; 
     3import schedframe.resources.computing.Node; 
    44import schedframe.resources.computing.ComputingResource; 
    55import schedframe.resources.computing.DataCenter; 
    … …  
    1717                double power = 0; 
    1818                DataCenter dataCenter = (DataCenter)resource; 
    19                 for(ComputingNode cn:dataCenter.getComputingNodes()){ 
     19                for(Node cn:dataCenter.getNodes()){ 
    2020                        PowerUsage powerUsage = cn.getPowerInterface().getRecentPowerUsage(); 
    2121                        power += (powerUsage == null ? 0 : powerUsage.getValue()); 

  • DCWoRMS/branches/coolemall/src/test/article2/recs/plugins/energy/IntelNodeEEP.java

    r1210 r1247  
    44import java.io.IOException; 
    55 
    6 import schedframe.resources.computing.ComputingNode; 
     6import schedframe.resources.computing.Node; 
    77import schedframe.resources.computing.Processor; 
    88import schedframe.resources.computing.profiles.energy.EnergyEvent; 
    … …  
    1515                        PhysicalResource resource) { 
    1616                double powerConsumption = 0; 
    17                 ComputingNode node = (ComputingNode) resource; 
     17                Node node = (Node) resource; 
    1818                 
    1919                try { 

  • DCWoRMS/branches/coolemall/src/test/article2/recs/plugins/energy/RecsNodeBaseEEP.java

    r1210 r1247  
    1010 
    1111import schedframe.events.scheduling.EventReason; 
    12 import schedframe.resources.computing.ComputingNode; 
     12import schedframe.resources.computing.Node; 
    1313import schedframe.resources.computing.ComputingResource; 
    1414import schedframe.resources.computing.Core; 
    … …  
    137137                 
    138138                ProcessingElements pe = (ProcessingElements) peUnit; 
    139                 if(pe.get(0) instanceof ComputingNode) 
    140                         return ((ComputingNode)pe.get(0)).getCategory(); 
     139                if(pe.get(0) instanceof Node) 
     140                        return ((Node)pe.get(0)).getCategory(); 
    141141                if(pe.get(0) instanceof Processor) 
    142142                        return ((Processor)pe.get(0)).getParent().getCategory(); 
    … …  
    147147        private int getFrequency(PEUnit peUnit){ 
    148148                ProcessingElements pe = (ProcessingElements) peUnit; 
    149                 if(pe.get(0) instanceof ComputingNode) 
    150                         return Double.valueOf(((ComputingNode)pe.get(0)).getProcessors().get(0).getPowerInterface().getFrequency()).intValue(); 
     149                if(pe.get(0) instanceof Node) 
     150                        return Double.valueOf(((Node)pe.get(0)).getProcessors().get(0).getPowerInterface().getFrequency()).intValue(); 
    151151                if(pe.get(0) instanceof Processor) 
    152152                        return Double.valueOf(((Processor)pe.get(0)).getPowerInterface().getFrequency()).intValue(); 

  • DCWoRMS/branches/coolemall/src/test/article2/recs/plugins/scheduling/RecsSP.java

    r828 r1247  
    77import java.util.ResourceBundle; 
    88 
    9 import schedframe.resources.computing.ComputingNode; 
     9import schedframe.resources.computing.Node; 
    1010import schedframe.scheduling.tasks.TaskInterface; 
    1111import test.article2.recs.utils.AppType; 
    … …  
    2727        } 
    2828         
    29         protected String createExecutivenessQuery(TaskInterface<?> task, ComputingNode node) { 
     29        protected String createExecutivenessQuery(TaskInterface<?> task, Node node) { 
    3030                Executable exec = (Executable)task; 
    3131                String query = getApplicationType(exec) + "." + getNodeCategory(node); 
    … …  
    3838        } 
    3939         
    40         private String getNodeCategory(ComputingNode node){ 
     40        private String getNodeCategory(Node node){ 
    4141                return node.getCategory(); 
    4242        } 

  • DCWoRMS/branches/coolemall/src/test/article2/recs/plugins/scheduling/exp1/RecsInIdleSP.java

    r1211 r1247  
    1313import schedframe.events.scheduling.SchedulingEvent; 
    1414import schedframe.resources.ResourceStatus; 
    15 import schedframe.resources.computing.ComputingNode; 
     15import schedframe.resources.computing.Node; 
    1616import schedframe.resources.computing.ComputingResource; 
    1717import schedframe.resources.computing.Core; 
    … …  
    5151                        TaskQueue q = queues.get(0); 
    5252 
    53                         List<ComputingNode> notSelectedNodes = resourceManager.getComputingNodes(); 
     53                        List<Node> notSelectedNodes = resourceManager.getNodes(); 
    5454                        // check all tasks in queue 
    5555                        for (int i = 0; i < q.size(); i++) { 
    … …  
    5757                                // if status of the tasks in READY 
    5858                                if (task.getStatus() == DCWormsTags.READY) { 
    59                                         ComputingNode node = chooseProvider(resourceManager, task); 
     59                                        Node node = chooseProvider(resourceManager, task); 
    6060                                        if (node != null) { 
    6161                                                node.getAirThroughputInterface().setAirThroughputState(StandardAirThroughputStateName.ON); 
    … …  
    7171        } 
    7272         
    73         private ComputingNode chooseProvider(ClusterResourceManager resourceManager, TaskInterface<?> task) { 
    74                 List<ComputingNode> nodes = filterNodes(resourceManager.getComputingNodes(), task); 
    75                 for(ComputingNode node: nodes){ 
     73        private Node chooseProvider(ClusterResourceManager resourceManager, TaskInterface<?> task) { 
     74                List<Node> nodes = filterNodes(resourceManager.getNodes(), task); 
     75                for(Node node: nodes){ 
    7676                        Integer id = Integer.parseInt(node.getName().split("_")[1]); 
    7777                        if((id >= START_ID  && id <= END_ID)){ 
    … …  
    8484 
    8585        private Map<ResourceUnitName, ResourceUnit> chooseResourcesForExecution( 
    86                         ComputingNode node, TaskInterface<?> task) { 
     86                        Node node, TaskInterface<?> task) { 
    8787 
    8888                Map<ResourceUnitName, ResourceUnit> map = new HashMap<ResourceUnitName, ResourceUnit>(); 
    … …  
    118118        } 
    119119         
    120         private List<ComputingNode> filterNodes(List<ComputingNode> nodes, TaskInterface<?> task){ 
    121                 List<ComputingNode> filteredNodes = new ArrayList<ComputingNode>(); 
    122                 for (ComputingNode node : nodes) { 
     120        private List<Node> filterNodes(List<Node> nodes, TaskInterface<?> task){ 
     121                List<Node> filteredNodes = new ArrayList<Node>(); 
     122                for (Node node : nodes) { 
    123123                        int cpuRequest; 
    124124                        try { 
    … …  
    161161        } 
    162162         
    163         private void adjustOtherFans(List<ComputingNode> nodes){ 
    164                 for(ComputingNode node : nodes){ 
     163        private void adjustOtherFans(List<Node> nodes){ 
     164                for(Node node : nodes){ 
    165165                        if(node.getFreeProcessorsNumber() == node.getProcessorsNumber()){ 
    166166                                //node.getAirThroughputInterface().setAirThroughputState(StandardAirThroughputStateName.FAN_OFF); 

  • DCWoRMS/branches/coolemall/src/test/article2/recs/plugins/scheduling/exp1/RecsInOffSP.java

    r1211 r1247  
    1313import schedframe.events.scheduling.SchedulingEvent; 
    1414import schedframe.resources.ResourceStatus; 
    15 import schedframe.resources.computing.ComputingNode; 
     15import schedframe.resources.computing.Node; 
    1616import schedframe.resources.computing.ComputingResource; 
    1717import schedframe.resources.computing.Core; 
    … …  
    5555                        TaskQueue q = queues.get(0); 
    5656 
    57                         List<ComputingNode> notSelectedNodes = resourceManager.getComputingNodes(); 
     57                        List<Node> notSelectedNodes = resourceManager.getNodes(); 
    5858                        // check all tasks in queue 
    5959                        for (int i = 0; i < q.size(); i++) { 
    … …  
    6161                                // if status of the tasks in READY 
    6262                                if (task.getStatus() == DCWormsTags.READY) { 
    63                                         ComputingNode node = chooseProvider(resourceManager, task); 
     63                                        Node node = chooseProvider(resourceManager, task); 
    6464                                        if (node != null) { 
    6565                                                node.getAirThroughputInterface().setAirThroughputState(StandardAirThroughputStateName.ON); 
    … …  
    6969                                } 
    7070                        } 
    71                         turnOffIdleNodes(resourceManager.getComputingNodes()); 
     71                        turnOffIdleNodes(resourceManager.getNodes()); 
    7272                        adjustOtherFans(notSelectedNodes); 
    7373                        break; 
    … …  
    7676        } 
    7777         
    78         private ComputingNode chooseProvider(ClusterResourceManager resourceManager, TaskInterface<?> task) { 
    79                 List<ComputingNode> nodes = filterNodes(resourceManager.getComputingNodes(), task); 
    80                 for(ComputingNode node: nodes){ 
     78        private Node chooseProvider(ClusterResourceManager resourceManager, TaskInterface<?> task) { 
     79                List<Node> nodes = filterNodes(resourceManager.getNodes(), task); 
     80                for(Node node: nodes){ 
    8181                        Integer id = Integer.parseInt(node.getName().split("_")[1]); 
    8282                        if((id >= START_ID  && id <= END_ID)){ 
    … …  
    9292 
    9393        private Map<ResourceUnitName, ResourceUnit> chooseResourcesForExecution( 
    94                         ComputingNode node, TaskInterface<?> task) { 
     94                        Node node, TaskInterface<?> task) { 
    9595 
    9696                Map<ResourceUnitName, ResourceUnit> map = new HashMap<ResourceUnitName, ResourceUnit>(); 
    … …  
    126126        } 
    127127         
    128         private List<ComputingNode> filterNodes(List<ComputingNode> nodes, TaskInterface<?> task){ 
    129                 List<ComputingNode> filteredNodes = new ArrayList<ComputingNode>(); 
    130                 for (ComputingNode node : nodes) { 
     128        private List<Node> filterNodes(List<Node> nodes, TaskInterface<?> task){ 
     129                List<Node> filteredNodes = new ArrayList<Node>(); 
     130                for (Node node : nodes) { 
    131131                        int cpuRequest; 
    132132                        try { 
    … …  
    169169        } 
    170170 
    171         private void turnOffIdleNodes(List<ComputingNode> nodes){ 
    172                 for(ComputingNode node : nodes){ 
     171        private void turnOffIdleNodes(List<Node> nodes){ 
     172                for(Node node : nodes){ 
    173173                        Processor proc = node.getProcessors().get(0); 
    174174                        int freeCores = 0; 
    … …  
    183183        } 
    184184         
    185         private void adjustOtherFans(List<ComputingNode> nodes){ 
    186                 for(ComputingNode node : nodes){ 
     185        private void adjustOtherFans(List<Node> nodes){ 
     186                for(Node node : nodes){ 
    187187                        if(node.getFreeProcessorsNumber() == node.getProcessorsNumber()){ 
    188188                                node.getAirThroughputInterface().setAirThroughputState(StandardAirThroughputStateName.OFF); 

  • DCWoRMS/branches/coolemall/src/test/article2/recs/plugins/scheduling/exp1/RecsInOutSP.java

    r1211 r1247  
    1616import schedframe.events.scheduling.SchedulingEvent; 
    1717import schedframe.resources.ResourceStatus; 
    18 import schedframe.resources.computing.ComputingNode; 
     18import schedframe.resources.computing.Node; 
    1919import schedframe.resources.computing.ComputingResource; 
    2020import schedframe.resources.computing.Core; 
    … …  
    5454                        TaskQueue q = queues.get(0); 
    5555 
    56                         List<ComputingNode> notSelectedNodes = resourceManager.getComputingNodes(); 
     56                        List<Node> notSelectedNodes = resourceManager.getNodes(); 
    5757                        // check all tasks in queue 
    5858                        for (int i = 0; i < q.size(); i++) { 
    … …  
    6060                                // if status of the tasks in READY 
    6161                                if (task.getStatus() == DCWormsTags.READY) { 
    62                                         ComputingNode node = chooseProvider(resourceManager, task); 
     62                                        Node node = chooseProvider(resourceManager, task); 
    6363                                        if (node != null) { 
    6464                                                node.getAirThroughputInterface().setAirThroughputState(StandardAirThroughputStateName.ON); 
    … …  
    7474        } 
    7575         
    76         private ComputingNode chooseProvider(ClusterResourceManager resourceManager, TaskInterface<?> task) { 
    77                 List<ComputingNode> nodes = filterNodes(resourceManager.getComputingNodes(), task); 
     76        private Node chooseProvider(ClusterResourceManager resourceManager, TaskInterface<?> task) { 
     77                List<Node> nodes = filterNodes(resourceManager.getNodes(), task); 
    7878                Collections.sort(nodes, new ResourceIdRandomComparator()); 
    79                 for(ComputingNode node: nodes){ 
     79                for(Node node: nodes){ 
    8080                        Integer id = Integer.parseInt(node.getName().split("_")[1]); 
    8181                        if((id >= START_ID  && id <= END_ID)){ 
    … …  
    8888 
    8989        private Map<ResourceUnitName, ResourceUnit> chooseResourcesForExecution( 
    90                         ComputingNode node, TaskInterface<?> task) { 
     90                        Node node, TaskInterface<?> task) { 
    9191 
    9292                Map<ResourceUnitName, ResourceUnit> map = new HashMap<ResourceUnitName, ResourceUnit>(); 
    … …  
    122122        } 
    123123         
    124         private List<ComputingNode> filterNodes(List<ComputingNode> nodes, TaskInterface<?> task){ 
    125                 List<ComputingNode> filteredNodes = new ArrayList<ComputingNode>(); 
    126                 for (ComputingNode node : nodes) { 
     124        private List<Node> filterNodes(List<Node> nodes, TaskInterface<?> task){ 
     125                List<Node> filteredNodes = new ArrayList<Node>(); 
     126                for (Node node : nodes) { 
    127127                        int cpuRequest; 
    128128                        try { 
    … …  
    165165        } 
    166166         
    167         private void adjustOtherFans(List<ComputingNode> nodes){ 
    168                 for(ComputingNode node : nodes){ 
     167        private void adjustOtherFans(List<Node> nodes){ 
     168                for(Node node : nodes){ 
    169169                        if(node.getFreeProcessorsNumber() == node.getProcessorsNumber()){ 
    170170                                //node.getAirThroughputInterface().setAirThroughputState(StandardAirThroughputStateName.FAN_OFF); 
    … …  
    177177 
    178178 
    179 class ResourceIdRandomComparator implements Comparator<ComputingNode>{ 
     179class ResourceIdRandomComparator implements Comparator<Node>{ 
    180180         
    181181        protected Random random; 
    … …  
    183183                random = new Random(5); 
    184184        } 
    185         public int compare(ComputingNode node1, ComputingNode node2){     
     185        public int compare(Node node1, Node node2){     
    186186                return random.nextInt(3) - 1; 
    187187            

  • DCWoRMS/branches/coolemall/src/test/article2/recs/plugins/scheduling/exp1/RecsOutIdleSP.java

    r1211 r1247  
    1313import schedframe.events.scheduling.SchedulingEvent; 
    1414import schedframe.resources.ResourceStatus; 
    15 import schedframe.resources.computing.ComputingNode; 
     15import schedframe.resources.computing.Node; 
    1616import schedframe.resources.computing.ComputingResource; 
    1717import schedframe.resources.computing.Core; 
    … …  
    5151                        TaskQueue q = queues.get(0); 
    5252 
    53                         List<ComputingNode> notSelectedNodes = resourceManager.getComputingNodes(); 
     53                        List<Node> notSelectedNodes = resourceManager.getNodes(); 
    5454                        // check all tasks in queue 
    5555                        for (int i = 0; i < q.size(); i++) { 
    … …  
    5757                                // if status of the tasks in READY 
    5858                                if (task.getStatus() == DCWormsTags.READY) { 
    59                                         ComputingNode node = chooseProvider(resourceManager, task); 
     59                                        Node node = chooseProvider(resourceManager, task); 
    6060                                        if (node != null) { 
    6161                                                node.getAirThroughputInterface().setAirThroughputState(StandardAirThroughputStateName.ON); 
    … …  
    7171        } 
    7272         
    73         private ComputingNode chooseProvider(ClusterResourceManager resourceManager, TaskInterface<?> task) { 
    74                 List<ComputingNode> nodes = filterNodes(resourceManager.getComputingNodes(), task); 
    75                 for(ComputingNode node: nodes){ 
     73        private Node chooseProvider(ClusterResourceManager resourceManager, TaskInterface<?> task) { 
     74                List<Node> nodes = filterNodes(resourceManager.getNodes(), task); 
     75                for(Node node: nodes){ 
    7676                        Integer id = Integer.parseInt(node.getName().split("_")[1]); 
    7777                        if((id >= START_ID  && id <= END_ID)){ 
    … …  
    8484 
    8585        private Map<ResourceUnitName, ResourceUnit> chooseResourcesForExecution( 
    86                         ComputingNode node, TaskInterface<?> task) { 
     86                        Node node, TaskInterface<?> task) { 
    8787 
    8888                Map<ResourceUnitName, ResourceUnit> map = new HashMap<ResourceUnitName, ResourceUnit>(); 
    … …  
    118118        } 
    119119         
    120         private List<ComputingNode> filterNodes(List<ComputingNode> nodes, TaskInterface<?> task){ 
    121                 List<ComputingNode> filteredNodes = new ArrayList<ComputingNode>(); 
    122                 for (ComputingNode node : nodes) { 
     120        private List<Node> filterNodes(List<Node> nodes, TaskInterface<?> task){ 
     121                List<Node> filteredNodes = new ArrayList<Node>(); 
     122                for (Node node : nodes) { 
    123123                        int cpuRequest; 
    124124                        try { 
    … …  
    161161        } 
    162162         
    163         private void adjustOtherFans(List<ComputingNode> nodes){ 
    164                 for(ComputingNode node : nodes){ 
     163        private void adjustOtherFans(List<Node> nodes){ 
     164                for(Node node : nodes){ 
    165165                        if(node.getFreeProcessorsNumber() == node.getProcessorsNumber()){ 
    166166                                //node.getAirThroughputInterface().setAirThroughputState(StandardAirThroughputStateName.FAN_OFF); 

  • DCWoRMS/branches/coolemall/src/test/article2/recs/plugins/scheduling/exp1/RecsOutOffSP.java

    r1211 r1247  
    1414import schedframe.events.scheduling.SchedulingEvent; 
    1515import schedframe.resources.ResourceStatus; 
    16 import schedframe.resources.computing.ComputingNode; 
     16import schedframe.resources.computing.Node; 
    1717import schedframe.resources.computing.ComputingResource; 
    1818import schedframe.resources.computing.Core; 
    … …  
    5656                        TaskQueue q = queues.get(0); 
    5757 
    58                         List<ComputingNode> notSelectedNodes = resourceManager.getComputingNodes(); 
     58                        List<Node> notSelectedNodes = resourceManager.getNodes(); 
    5959                        // check all tasks in queue 
    6060                        for (int i = 0; i < q.size(); i++) { 
    … …  
    6262                                // if status of the tasks in READY 
    6363                                if (task.getStatus() == DCWormsTags.READY) { 
    64                                         ComputingNode node = chooseProvider(resourceManager, task); 
     64                                        Node node = chooseProvider(resourceManager, task); 
    6565                                        if (node != null) { 
    6666                                                node.getAirThroughputInterface().setAirThroughputState(StandardAirThroughputStateName.ON); 
    … …  
    7070                                } 
    7171                        } 
    72                         turnOffIdleNodes(resourceManager.getComputingNodes()); 
     72                        turnOffIdleNodes(resourceManager.getNodes()); 
    7373                        adjustOtherFans(notSelectedNodes); 
    7474                        break; 
    … …  
    7777        } 
    7878         
    79         private ComputingNode chooseProvider(ClusterResourceManager resourceManager, TaskInterface<?> task) { 
    80                 List<ComputingNode> nodes = filterNodes(resourceManager.getComputingNodes(), task); 
    81                 for(ComputingNode node: nodes){ 
     79        private Node chooseProvider(ClusterResourceManager resourceManager, TaskInterface<?> task) { 
     80                List<Node> nodes = filterNodes(resourceManager.getNodes(), task); 
     81                for(Node node: nodes){ 
    8282                        Integer id = Integer.parseInt(node.getName().split("_")[1]); 
    8383                        if((id >= START_ID  && id <= END_ID)){ 
    … …  
    9393 
    9494        private Map<ResourceUnitName, ResourceUnit> chooseResourcesForExecution( 
    95                         ComputingNode node, TaskInterface<?> task) { 
     95                        Node node, TaskInterface<?> task) { 
    9696 
    9797                Map<ResourceUnitName, ResourceUnit> map = new HashMap<ResourceUnitName, ResourceUnit>(); 
    … …  
    127127        } 
    128128         
    129         private List<ComputingNode> filterNodes(List<ComputingNode> nodes, TaskInterface<?> task){ 
    130                 List<ComputingNode> filteredNodes = new ArrayList<ComputingNode>(); 
    131                 for (ComputingNode node : nodes) { 
     129        private List<Node> filterNodes(List<Node> nodes, TaskInterface<?> task){ 
     130                List<Node> filteredNodes = new ArrayList<Node>(); 
     131                for (Node node : nodes) { 
    132132                        int cpuRequest; 
    133133                        try { 
    … …  
    170170        } 
    171171 
    172         private void turnOffIdleNodes(List<ComputingNode> nodes){ 
    173                 for(ComputingNode node : nodes){ 
     172        private void turnOffIdleNodes(List<Node> nodes){ 
     173                for(Node node : nodes){ 
    174174                        Processor proc = node.getProcessors().get(0); 
    175175                        int freeCores = 0; 
    … …  
    184184        } 
    185185         
    186         private void adjustOtherFans(List<ComputingNode> nodes){ 
    187                 for(ComputingNode node : nodes){ 
     186        private void adjustOtherFans(List<Node> nodes){ 
     187                for(Node node : nodes){ 
    188188                        if(node.getFreeProcessorsNumber() == node.getProcessorsNumber()){ 
    189189                                node.getAirThroughputInterface().setAirThroughputState(StandardAirThroughputStateName.OFF); 

  • DCWoRMS/branches/coolemall/src/test/article2/recs/plugins/scheduling/exp2/RecsIn2OutSP.java

    r1211 r1247  
    1515import schedframe.events.scheduling.SchedulingEvent; 
    1616import schedframe.resources.ResourceStatus; 
    17 import schedframe.resources.computing.ComputingNode; 
     17import schedframe.resources.computing.Node; 
    1818import schedframe.resources.computing.ComputingResource; 
    1919import schedframe.resources.computing.Core; 
    … …  
    5353                        TaskQueue q = queues.get(0); 
    5454 
    55                         List<ComputingNode> notSelectedNodes = resourceManager.getComputingNodes(); 
     55                        List<Node> notSelectedNodes = resourceManager.getNodes(); 
    5656                        // check all tasks in queue 
    5757                        for (int i = 0; i < q.size(); i++) { 
    … …  
    5959                                // if status of the tasks in READY 
    6060                                if (task.getStatus() == DCWormsTags.READY) { 
    61                                         ComputingNode node = chooseProvider(resourceManager, task); 
     61                                        Node node = chooseProvider(resourceManager, task); 
    6262                                        if (node != null) { 
    6363                                                node.getAirThroughputInterface().setAirThroughputState(StandardAirThroughputStateName.ON); 
    … …  
    7373        } 
    7474         
    75         private ComputingNode chooseProvider(ClusterResourceManager resourceManager, TaskInterface<?> task) { 
    76                 List<ComputingNode> nodes = filterNodes(resourceManager.getComputingNodes(), task); 
     75        private Node chooseProvider(ClusterResourceManager resourceManager, TaskInterface<?> task) { 
     76                List<Node> nodes = filterNodes(resourceManager.getNodes(), task); 
    7777                Collections.sort(nodes, new ResourceIdComparator()); 
    78                 for(ComputingNode node: nodes){ 
     78                for(Node node: nodes){ 
    7979                        Integer id = Integer.parseInt(node.getName().split("_")[1]); 
    8080                        if((id >= START_ID  && id <= END_ID)){ 
    … …  
    8888 
    8989        private Map<ResourceUnitName, ResourceUnit> chooseResourcesForExecution( 
    90                         ComputingNode node, TaskInterface<?> task) { 
     90                        Node node, TaskInterface<?> task) { 
    9191 
    9292                Map<ResourceUnitName, ResourceUnit> map = new HashMap<ResourceUnitName, ResourceUnit>(); 
    … …  
    122122        } 
    123123         
    124         private List<ComputingNode> filterNodes(List<ComputingNode> nodes, TaskInterface<?> task){ 
    125                 List<ComputingNode> filteredNodes = new ArrayList<ComputingNode>(); 
    126                 for (ComputingNode node : nodes) { 
     124        private List<Node> filterNodes(List<Node> nodes, TaskInterface<?> task){ 
     125                List<Node> filteredNodes = new ArrayList<Node>(); 
     126                for (Node node : nodes) { 
    127127                        int cpuRequest; 
    128128                        try { 
    … …  
    165165        } 
    166166         
    167         private void adjustOtherFans(List<ComputingNode> nodes){ 
    168                 for(ComputingNode node : nodes){ 
     167        private void adjustOtherFans(List<Node> nodes){ 
     168                for(Node node : nodes){ 
    169169                        if(node.getFreeProcessorsNumber() == node.getProcessorsNumber()){ 
    170170                                //node.getAirThroughputInterface().setAirThroughputState(StandardAirThroughputStateName.FAN_OFF); 
    … …  
    175175        } 
    176176         
    177         class ResourceIdComparator implements Comparator<ComputingNode> { 
    178  
    179                 public int compare(ComputingNode node1, ComputingNode node2) { 
     177        class ResourceIdComparator implements Comparator<Node> { 
     178 
     179                public int compare(Node node1, Node node2) { 
    180180                        Integer id1 = Integer.parseInt(node1.getName().split("_")[1]); 
    181181                        Integer id2 = Integer.parseInt(node2.getName().split("_")[1]); 

  • DCWoRMS/branches/coolemall/src/test/article2/recs/plugins/scheduling/exp2/RecsLeft2RightSP.java

    r1211 r1247  
    1515import schedframe.events.scheduling.SchedulingEvent; 
    1616import schedframe.resources.ResourceStatus; 
    17 import schedframe.resources.computing.ComputingNode; 
     17import schedframe.resources.computing.Node; 
    1818import schedframe.resources.computing.ComputingResource; 
    1919import schedframe.resources.computing.Core; 
    … …  
    5454                        TaskQueue q = queues.get(0); 
    5555 
    56                         List<ComputingNode> notSelectedNodes = resourceManager.getComputingNodes(); 
     56                        List<Node> notSelectedNodes = resourceManager.getNodes(); 
    5757                        // check all tasks in queue 
    5858                        for (int i = 0; i < q.size(); i++) { 
    … …  
    6060                                // if status of the tasks in READY 
    6161                                if (task.getStatus() == DCWormsTags.READY) { 
    62                                         ComputingNode node = chooseProvider(resourceManager, task); 
     62                                        Node node = chooseProvider(resourceManager, task); 
    6363                                        if (node != null) { 
    6464                                                node.getAirThroughputInterface().setAirThroughputState(StandardAirThroughputStateName.ON); 
    … …  
    7474        } 
    7575 
    76         private ComputingNode chooseProvider(ClusterResourceManager resourceManager, TaskInterface<?> task) { 
    77                 List<ComputingNode> nodes = filterNodes(resourceManager.getComputingNodes(), task); 
     76        private Node chooseProvider(ClusterResourceManager resourceManager, TaskInterface<?> task) { 
     77                List<Node> nodes = filterNodes(resourceManager.getNodes(), task); 
    7878                Collections.sort(nodes, new ResourceIdComparator()); 
    79                 for (ComputingNode node : nodes) { 
     79                for (Node node : nodes) { 
    8080                        Integer id = Integer.parseInt(node.getName().split("_")[1]); 
    8181                        if ((id >= START_ID && id <= END_ID)) { 
    … …  
    8888        } 
    8989 
    90         private Map<ResourceUnitName, ResourceUnit> chooseResourcesForExecution(ComputingNode node, TaskInterface<?> task) { 
     90        private Map<ResourceUnitName, ResourceUnit> chooseResourcesForExecution(Node node, TaskInterface<?> task) { 
    9191 
    9292                Map<ResourceUnitName, ResourceUnit> map = new HashMap<ResourceUnitName, ResourceUnit>(); 
    … …  
    122122        } 
    123123 
    124         private List<ComputingNode> filterNodes(List<ComputingNode> nodes, TaskInterface<?> task) { 
    125                 List<ComputingNode> filteredNodes = new ArrayList<ComputingNode>(); 
    126                 for (ComputingNode node : nodes) { 
     124        private List<Node> filterNodes(List<Node> nodes, TaskInterface<?> task) { 
     125                List<Node> filteredNodes = new ArrayList<Node>(); 
     126                for (Node node : nodes) { 
    127127                        int cpuRequest; 
    128128                        try { 
    … …  
    165165        } 
    166166 
    167         private void adjustOtherFans(List<ComputingNode> nodes) { 
    168                 for (ComputingNode node : nodes) { 
     167        private void adjustOtherFans(List<Node> nodes) { 
     168                for (Node node : nodes) { 
    169169                        if (node.getFreeProcessorsNumber() == node.getProcessorsNumber()) { 
    170170                                // node.getAirThroughputInterface().setAirThroughputState(StandardAirThroughputStateName.FAN_OFF); 
    … …  
    175175        } 
    176176 
    177         class ResourceIdComparator implements Comparator<ComputingNode> { 
     177        class ResourceIdComparator implements Comparator<Node> { 
    178178 
    179                 public int compare(ComputingNode node1, ComputingNode node2) { 
     179                public int compare(Node node1, Node node2) { 
    180180                        Integer id1 = Integer.parseInt(node1.getName().split("_")[1]); 
    181181                        Integer id2 = Integer.parseInt(node2.getName().split("_")[1]); 

  • DCWoRMS/branches/coolemall/src/test/article2/recs/plugins/scheduling/exp2/RecsOut2InSP.java

    r1211 r1247  
    1515import schedframe.events.scheduling.SchedulingEvent; 
    1616import schedframe.resources.ResourceStatus; 
    17 import schedframe.resources.computing.ComputingNode; 
     17import schedframe.resources.computing.Node; 
    1818import schedframe.resources.computing.ComputingResource; 
    1919import schedframe.resources.computing.Core; 
    … …  
    5353                        TaskQueue q = queues.get(0); 
    5454 
    55                         List<ComputingNode> notSelectedNodes = resourceManager.getComputingNodes(); 
     55                        List<Node> notSelectedNodes = resourceManager.getNodes(); 
    5656                        // check all tasks in queue 
    5757                        for (int i = 0; i < q.size(); i++) { 
    … …  
    5959                                // if status of the tasks in READY 
    6060                                if (task.getStatus() == DCWormsTags.READY) { 
    61                                         ComputingNode node = chooseProvider(resourceManager, task); 
     61                                        Node node = chooseProvider(resourceManager, task); 
    6262                                        if (node != null) { 
    6363                                                node.getAirThroughputInterface().setAirThroughputState(StandardAirThroughputStateName.ON); 
    … …  
    7373        } 
    7474         
    75         private ComputingNode chooseProvider(ClusterResourceManager resourceManager, TaskInterface<?> task) { 
    76                 List<ComputingNode> nodes = filterNodes(resourceManager.getComputingNodes(), task); 
     75        private Node chooseProvider(ClusterResourceManager resourceManager, TaskInterface<?> task) { 
     76                List<Node> nodes = filterNodes(resourceManager.getNodes(), task); 
    7777                Collections.sort(nodes, new ResourceIdComparator()); 
    78                 for(ComputingNode node: nodes){ 
     78                for(Node node: nodes){ 
    7979                        Integer id = Integer.parseInt(node.getName().split("_")[1]); 
    8080                        if((id >= START_ID  && id <= END_ID)){ 
    … …  
    8787 
    8888        private Map<ResourceUnitName, ResourceUnit> chooseResourcesForExecution( 
    89                         ComputingNode node, TaskInterface<?> task) { 
     89                        Node node, TaskInterface<?> task) { 
    9090 
    9191                Map<ResourceUnitName, ResourceUnit> map = new HashMap<ResourceUnitName, ResourceUnit>(); 
    … …  
    121121        } 
    122122         
    123         private List<ComputingNode> filterNodes(List<ComputingNode> nodes, TaskInterface<?> task){ 
    124                 List<ComputingNode> filteredNodes = new ArrayList<ComputingNode>(); 
    125                 for (ComputingNode node : nodes) { 
     123        private List<Node> filterNodes(List<Node> nodes, TaskInterface<?> task){ 
     124                List<Node> filteredNodes = new ArrayList<Node>(); 
     125                for (Node node : nodes) { 
    126126                        int cpuRequest; 
    127127                        try { 
    … …  
    164164        } 
    165165         
    166         private void adjustOtherFans(List<ComputingNode> nodes){ 
    167                 for(ComputingNode node : nodes){ 
     166        private void adjustOtherFans(List<Node> nodes){ 
     167                for(Node node : nodes){ 
    168168                        if(node.getFreeProcessorsNumber() == node.getProcessorsNumber()){ 
    169169                                //node.getAirThroughputInterface().setAirThroughputState(StandardAirThroughputStateName.FAN_OFF); 
    … …  
    174174        } 
    175175         
    176         class ResourceIdComparator implements Comparator<ComputingNode> { 
     176        class ResourceIdComparator implements Comparator<Node> { 
    177177 
    178                 public int compare(ComputingNode node1, ComputingNode node2) { 
     178                public int compare(Node node1, Node node2) { 
    179179                        Integer id1 = Integer.parseInt(node1.getName().split("_")[1]); 
    180180                        Integer id2 = Integer.parseInt(node2.getName().split("_")[1]); 

  • DCWoRMS/branches/coolemall/src/test/article2/recs/plugins/scheduling/exp2/RecsRandomSP.java

    r1211 r1247  
    1111import schedframe.events.scheduling.SchedulingEvent; 
    1212import schedframe.resources.ResourceStatus; 
    13 import schedframe.resources.computing.ComputingNode; 
     13import schedframe.resources.computing.Node; 
    1414import schedframe.resources.computing.ComputingResource; 
    1515import schedframe.resources.computing.Core; 
    … …  
    5050                        TaskQueue q = queues.get(0); 
    5151 
    52                         List<ComputingNode> notSelectedNodes = resourceManager.getComputingNodes(); 
     52                        List<Node> notSelectedNodes = resourceManager.getNodes(); 
    5353                        // check all tasks in queue 
    5454                        for (int i = 0; i < q.size(); i++) { 
    … …  
    5656                                // if status of the tasks in READY 
    5757                                if (task.getStatus() == DCWormsTags.READY) { 
    58                                         ComputingNode node = chooseRandomProvider(resourceManager, task); 
     58                                        Node node = chooseRandomProvider(resourceManager, task); 
    5959                                        if (node != null) { 
    6060                                                node.getAirThroughputInterface().setAirThroughputState(StandardAirThroughputStateName.ON); 
    … …  
    7070        } 
    7171         
    72         private ComputingNode chooseRandomProvider(ClusterResourceManager resourceManager, TaskInterface<?> task) { 
    73                 List<ComputingNode> nodes = filterNodes(resourceManager.getComputingNodes(), task); 
     72        private Node chooseRandomProvider(ClusterResourceManager resourceManager, TaskInterface<?> task) { 
     73                List<Node> nodes = filterNodes(resourceManager.getNodes(), task); 
    7474                if(nodes.size() > 0) 
    7575                        return randomNode(nodes); 
    … …  
    7878 
    7979        private Map<ResourceUnitName, ResourceUnit> chooseResourcesForExecution( 
    80                         ComputingNode node, TaskInterface<?> task) { 
     80                        Node node, TaskInterface<?> task) { 
    8181 
    8282                Map<ResourceUnitName, ResourceUnit> map = new HashMap<ResourceUnitName, ResourceUnit>(); 
    … …  
    112112        } 
    113113         
    114         private List<ComputingNode> filterNodes(List<ComputingNode> nodes, TaskInterface<?> task){ 
    115                 List<ComputingNode> filteredNodes = new ArrayList<ComputingNode>(); 
    116                 for (ComputingNode node : nodes) { 
     114        private List<Node> filterNodes(List<Node> nodes, TaskInterface<?> task){ 
     115                List<Node> filteredNodes = new ArrayList<Node>(); 
     116                for (Node node : nodes) { 
    117117                        int cpuRequest; 
    118118                        try { 
    … …  
    145145        } 
    146146         
    147         private ComputingNode randomNode(List<ComputingNode> nodes){ 
     147        private Node randomNode(List<Node> nodes){ 
    148148                return nodes.get(rand.nextInt(nodes.size())); 
    149149        } 
    150150         
    151         private void adjustOtherFans(List<ComputingNode> nodes){ 
    152                 for(ComputingNode node : nodes){ 
     151        private void adjustOtherFans(List<Node> nodes){ 
     152                for(Node node : nodes){ 
    153153                        if(node.getFreeProcessorsNumber() == node.getProcessorsNumber()){ 
    154154                                node.getAirThroughputInterface().setAirThroughputState(StandardAirThroughputStateName.OFF); 

  • DCWoRMS/branches/coolemall/src/test/article2/recs/plugins/timeestimation/RecsTimeEstimationPlugin.java

    r826 r1247  
    1010 
    1111import schedframe.events.scheduling.SchedulingEvent; 
    12 import schedframe.resources.computing.ComputingNode; 
     12import schedframe.resources.computing.Node; 
    1313import schedframe.resources.computing.Core; 
    1414import schedframe.resources.computing.Processor; 
    … …  
    7474                 
    7575                ProcessingElements pe = (ProcessingElements) peUnit; 
    76                 if(pe.get(0) instanceof ComputingNode) 
    77                         return ((ComputingNode)pe.get(0)).getCategory(); 
     76                if(pe.get(0) instanceof Node) 
     77                        return ((Node)pe.get(0)).getCategory(); 
    7878                if(pe.get(0) instanceof Processor) 
    7979                        return ((Processor)pe.get(0)).getParent().getCategory(); 
    … …  
    8484        private int getFrequency(PEUnit peUnit){ 
    8585                ProcessingElements pe = (ProcessingElements) peUnit; 
    86                 if(pe.get(0) instanceof ComputingNode) 
    87                         return Double.valueOf(((ComputingNode)pe.get(0)).getProcessors().get(0).getPowerInterface().getFrequency()).intValue(); 
     86                if(pe.get(0) instanceof Node) 
     87                        return Double.valueOf(((Node)pe.get(0)).getProcessors().get(0).getPowerInterface().getFrequency()).intValue(); 
    8888                if(pe.get(0) instanceof Processor) 
    8989                        return Double.valueOf(((Processor)pe.get(0)).getPowerInterface().getFrequency()).intValue(); 

  • DCWoRMS/branches/coolemall/src/test/drs_tst/recs/plugins/energy/AmdNodeEEP.java

    r1243 r1247  
    44import java.io.IOException; 
    55 
    6 import schedframe.resources.computing.ComputingNode; 
     6import schedframe.resources.computing.Node; 
    77import schedframe.resources.computing.Processor; 
    88import schedframe.resources.computing.profiles.energy.EnergyEvent; 
    … …  
    1818                double powerConsumption = 0; 
    1919                 
    20                 ComputingNode node = (ComputingNode) resource; 
     20                Node node = (Node) resource; 
    2121                try { 
    2222                        if(jobRegistry.getRunningTasks().size() > 0) { 

  • DCWoRMS/branches/coolemall/src/test/drs_tst/recs/plugins/energy/AtomD510NodeEEP.java

    r1243 r1247  
    44import java.io.IOException; 
    55 
    6 import schedframe.resources.computing.ComputingNode; 
     6import schedframe.resources.computing.Node; 
    77import schedframe.resources.computing.Processor; 
    88import schedframe.resources.computing.profiles.energy.EnergyEvent; 
    … …  
    1515                        PhysicalResource resource) { 
    1616                double powerConsumption = 0; 
    17                 ComputingNode node = (ComputingNode) resource; 
     17                Node node = (Node) resource; 
    1818                try { 
    1919                        if(jobRegistry.getRunningTasks().size() > 0) { 

  • DCWoRMS/branches/coolemall/src/test/drs_tst/recs/plugins/energy/AtomZ510NodeEEP.java

    r1243 r1247  
    44import java.io.IOException; 
    55 
    6 import schedframe.resources.computing.ComputingNode; 
     6import schedframe.resources.computing.Node; 
    77import schedframe.resources.computing.Processor; 
    88import schedframe.resources.computing.profiles.energy.EnergyEvent; 
    … …  
    1717                        PhysicalResource resource) { 
    1818                double powerConsumption = 0; 
    19                 ComputingNode node = (ComputingNode) resource; 
     19                Node node = (Node) resource; 
    2020                try { 
    2121                        if(jobRegistry.getRunningTasks().size() > 0) { 

  • DCWoRMS/branches/coolemall/src/test/drs_tst/recs/plugins/energy/IntelNodeEEP.java

    r1243 r1247  
    44import java.io.IOException; 
    55 
    6 import schedframe.resources.computing.ComputingNode; 
     6import schedframe.resources.computing.Node; 
    77import schedframe.resources.computing.Processor; 
    88import schedframe.resources.computing.profiles.energy.EnergyEvent; 
    … …  
    1515                        PhysicalResource resource) { 
    1616                double powerConsumption = 0; 
    17                 ComputingNode node = (ComputingNode) resource; 
     17                Node node = (Node) resource; 
    1818                 
    1919                try { 

  • DCWoRMS/branches/coolemall/src/test/drs_tst/recs/plugins/energy/RecsNodeBaseEEP.java

    r1245 r1247  
    99import java.util.ResourceBundle; 
    1010 
    11 import schedframe.resources.computing.ComputingNode; 
     11import schedframe.resources.computing.Node; 
    1212import schedframe.resources.computing.Core; 
    1313import schedframe.resources.computing.Processor; 
    … …  
    5454                 
    5555                ProcessingElements pe = (ProcessingElements) peUnit; 
    56                 if(pe.get(0) instanceof ComputingNode) 
    57                         return ((ComputingNode)pe.get(0)).getCategory(); 
     56                if(pe.get(0) instanceof Node) 
     57                        return ((Node)pe.get(0)).getCategory(); 
    5858                Core core = (Core)pe.get(0); 
    5959                return core.getParent().getParent().getCategory(); 
    … …  
    6262        private int getFrequency(PEUnit peUnit){ 
    6363                ProcessingElements pe = (ProcessingElements) peUnit; 
    64                 if(pe.get(0) instanceof ComputingNode) 
    65                         return Double.valueOf(((ComputingNode)pe.get(0)).getProcessors().get(0).getPowerInterface().getFrequency()).intValue(); 
     64                if(pe.get(0) instanceof Node) 
     65                        return Double.valueOf(((Node)pe.get(0)).getProcessors().get(0).getPowerInterface().getFrequency()).intValue(); 
    6666                Core core = (Core)pe.get(0); 
    6767                Processor proc = (Processor) core.getParent(); 

  • DCWoRMS/branches/coolemall/src/test/drs_tst/recs/plugins/scheduling/RecsExclusivenessDFSSP.java

    r1245 r1247  
    1414import schedframe.events.scheduling.SchedulingEvent; 
    1515import schedframe.resources.ResourceStatus; 
    16 import schedframe.resources.computing.ComputingNode; 
     16import schedframe.resources.computing.Node; 
    1717import schedframe.resources.computing.ComputingResource; 
    1818import schedframe.resources.computing.Core; 
    … …  
    7575                Map<ResourceUnitName, ResourceUnit> map = new HashMap<ResourceUnitName, ResourceUnit>(); 
    7676                 
    77                 List<ComputingNode> nodes = resourceManager.getComputingNodes(); 
    78                 List<ComputingNode> avNodes = filterNodes(nodes, task); 
     77                List<Node> nodes = resourceManager.getNodes(); 
     78                List<Node> avNodes = filterNodes(nodes, task); 
    7979                if(avNodes.size() == 0) 
    8080                        return null; 
    81                 ComputingNode node = randomNode(avNodes); 
     81                Node node = randomNode(avNodes); 
    8282 
    8383                int cpuRequest; 
    … …  
    111111        } 
    112112         
    113         private List<ComputingNode> filterNodes(List<ComputingNode> nodes, TaskInterface<?> task){ 
    114                 List<ComputingNode> filteredNodes = new ArrayList<ComputingNode>(); 
    115                 for (ComputingNode node : nodes) { 
     113        private List<Node> filterNodes(List<Node> nodes, TaskInterface<?> task){ 
     114                List<Node> filteredNodes = new ArrayList<Node>(); 
     115                for (Node node : nodes) { 
    116116                        int cpuRequest; 
    117117                        try { 
    … …  
    154154        } 
    155155         
    156         private ComputingNode randomNode(List<ComputingNode> nodes){ 
     156        private Node randomNode(List<Node> nodes){ 
    157157                return nodes.get(rand.nextInt(nodes.size())); 
    158158        } 

  • DCWoRMS/branches/coolemall/src/test/drs_tst/recs/plugins/scheduling/RecsExclusivenessEnOptDFSSP.java

    r1245 r1247  
    1818import schedframe.events.scheduling.SchedulingEvent; 
    1919import schedframe.resources.ResourceStatus; 
    20 import schedframe.resources.computing.ComputingNode; 
     20import schedframe.resources.computing.Node; 
    2121import schedframe.resources.computing.ComputingResource; 
    2222import schedframe.resources.computing.Core; 
    … …  
    8585 
    8686                Map<ResourceUnitName, ResourceUnit> map; 
    87                 List<ComputingNode> nodes = resourceManager.getComputingNodes(); 
     87                List<Node> nodes = resourceManager.getNodes(); 
    8888                Collections.sort(nodes, new EnergyComparator(task)); 
    8989                //System.out.println("*****"); 
    90                 for (ComputingNode node : nodes) { 
     90                for (Node node : nodes) { 
    9191                        //System.out.println(node.getCategory()); 
    9292                        int cpuRequest; 
    … …  
    153153 
    154154         
    155         protected String createQuery(TaskInterface<?> task, ComputingNode node) { 
     155        protected String createQuery(TaskInterface<?> task, Node node) { 
    156156                String query; 
    157157                query = getApplicationType(task) + "." + getNodeCategory(node) + "." + getFrequency(node) + "." + getCoreCnt(task); 
    … …  
    164164        } 
    165165         
    166         private String getNodeCategory(ComputingNode node){ 
     166        private String getNodeCategory(Node node){ 
    167167 
    168168                return node.getCategory(); 
    169169        } 
    170170         
    171         private int getFrequency(ComputingNode node){ 
     171        private int getFrequency(Node node){ 
    172172                Processor proc = (Processor) node.getProcessors().get(0); 
    173173                double freq = proc.getPowerInterface().getFrequency(); 
    … …  
    208208                return timeBundle; 
    209209        } 
    210         class EnergyComparator implements Comparator<ComputingNode>{ 
     210        class EnergyComparator implements Comparator<Node>{ 
    211211                private TaskInterface<?> task; 
    212212                 
    … …  
    215215                } 
    216216                 
    217             public int compare(ComputingNode node1, ComputingNode node2){     
     217            public int compare(Node node1, Node node2){     
    218218                double node1EU = Double.MAX_VALUE; 
    219219                double node2EU = Double.MAX_VALUE; 

  • DCWoRMS/branches/coolemall/src/test/drs_tst/recs/plugins/scheduling/RecsExclusivenessEnOptNodePowManSP.java

    r1120 r1247  
    1818import schedframe.events.scheduling.SchedulingEvent; 
    1919import schedframe.resources.ResourceStatus; 
    20 import schedframe.resources.computing.ComputingNode; 
     20import schedframe.resources.computing.Node; 
    2121import schedframe.resources.computing.ComputingResource; 
    2222import schedframe.resources.computing.Core; 
    … …  
    7676                                } 
    7777                        } 
    78                         turnOffIdleNodes(resourceManager.getComputingNodes()); 
     78                        turnOffIdleNodes(resourceManager.getNodes()); 
    7979                        break; 
    8080                } 
    … …  
    8686 
    8787                Map<ResourceUnitName, ResourceUnit> map; 
    88                 List<ComputingNode> nodes = resourceManager.getComputingNodes(); 
     88                List<Node> nodes = resourceManager.getNodes(); 
    8989                Collections.sort(nodes, new EnergyComparator(task)); 
    90                 for (ComputingNode node : nodes) { 
     90                for (Node node : nodes) { 
    9191                        int cpuRequest; 
    9292                        try { 
    … …  
    156156 
    157157         
    158         protected String createQuery(TaskInterface<?> task, ComputingNode node) { 
     158        protected String createQuery(TaskInterface<?> task, Node node) { 
    159159                String query; 
    160160                query = getApplicationType(task) + "." + getNodeCategory(node) + "." + getFrequency(node) + "." + getCoreCnt(task); 
    … …  
    167167        } 
    168168         
    169         private String getNodeCategory(ComputingNode node){ 
     169        private String getNodeCategory(Node node){ 
    170170 
    171171                return node.getCategory(); 
    172172        } 
    173173         
    174         private int getFrequency(ComputingNode node){ 
     174        private int getFrequency(Node node){ 
    175175                Processor proc = (Processor) node.getProcessors().get(0); 
    176176                double freq = proc.getPowerInterface().getFrequency(); 
    … …  
    211211                return timeBundle; 
    212212        } 
    213         class EnergyComparator implements Comparator<ComputingNode>{ 
     213        class EnergyComparator implements Comparator<Node>{ 
    214214                private TaskInterface<?> task; 
    215215                 
    … …  
    218218                } 
    219219                 
    220             public int compare(ComputingNode node1, ComputingNode node2){     
     220            public int compare(Node node1, Node node2){     
    221221                double node1EU = Double.MAX_VALUE; 
    222222                double node2EU = Double.MAX_VALUE; 
    … …  
    248248        } 
    249249         
    250         private void turnOffIdleNodes(List<ComputingNode> nodes){ 
    251                 for(ComputingNode node : nodes){ 
     250        private void turnOffIdleNodes(List<Node> nodes){ 
     251                for(Node node : nodes){ 
    252252                        Processor proc = node.getProcessors().get(0); 
    253253                        int freeCores = 0; 

  • DCWoRMS/branches/coolemall/src/test/drs_tst/recs/plugins/scheduling/RecsExclusivenessEnOptSP.java

    r1245 r1247  
    1818import schedframe.events.scheduling.SchedulingEvent; 
    1919import schedframe.resources.ResourceStatus; 
    20 import schedframe.resources.computing.ComputingNode; 
     20import schedframe.resources.computing.Node; 
    2121import schedframe.resources.computing.ComputingResource; 
    2222import schedframe.resources.computing.Core; 
    … …  
    8383 
    8484                Map<ResourceUnitName, ResourceUnit> map; 
    85                 List<ComputingNode> nodes = resourceManager.getComputingNodes(); 
     85                List<Node> nodes = resourceManager.getNodes(); 
    8686                Collections.sort(nodes, new EnergyComparator(task)); 
    8787                //System.out.println("*****"); 
    88                 for (ComputingNode node : nodes) { 
     88                for (Node node : nodes) { 
    8989                        //System.out.println(node.getCategory()); 
    9090                        int cpuRequest; 
    … …  
    151151 
    152152         
    153         protected String createQuery(TaskInterface<?> task, ComputingNode node) { 
     153        protected String createQuery(TaskInterface<?> task, Node node) { 
    154154                String query; 
    155155                query = getApplicationType(task) + "." + getNodeCategory(node) + "." + getFrequency(node) + "." + getCoreCnt(task); 
    … …  
    162162        } 
    163163         
    164         private String getNodeCategory(ComputingNode node){ 
     164        private String getNodeCategory(Node node){ 
    165165 
    166166                return node.getCategory(); 
    167167        } 
    168168         
    169         private int getFrequency(ComputingNode node){ 
     169        private int getFrequency(Node node){ 
    170170                Processor proc = (Processor) node.getProcessors().get(0); 
    171171                double freq = proc.getPowerInterface().getFrequency(); 
    … …  
    207207                return timeBundle; 
    208208        } 
    209         class EnergyComparator implements Comparator<ComputingNode>{ 
     209        class EnergyComparator implements Comparator<Node>{ 
    210210                private TaskInterface<?> task; 
    211211                 
    … …  
    214214                } 
    215215                 
    216             public int compare(ComputingNode node1, ComputingNode node2){     
     216            public int compare(Node node1, Node node2){     
    217217                double node1EU = Double.MAX_VALUE; 
    218218                double node2EU = Double.MAX_VALUE; 

  • DCWoRMS/branches/coolemall/src/test/drs_tst/recs/plugins/scheduling/RecsExclusivenessRandomNodePowManSP.java

    r1120 r1247  
    1414import schedframe.events.scheduling.SchedulingEvent; 
    1515import schedframe.resources.ResourceStatus; 
    16 import schedframe.resources.computing.ComputingNode; 
     16import schedframe.resources.computing.Node; 
    1717import schedframe.resources.computing.ComputingResource; 
    1818import schedframe.resources.computing.Core; 
    … …  
    6464                                } 
    6565                        } 
    66                         turnOffIdleNodes(resourceManager.getComputingNodes()); 
     66                        turnOffIdleNodes(resourceManager.getNodes()); 
    6767                        break; 
    6868                } 
    … …  
    7575                Map<ResourceUnitName, ResourceUnit> map = new HashMap<ResourceUnitName, ResourceUnit>(); 
    7676                 
    77                 List<ComputingNode> nodes = resourceManager.getComputingNodes(); 
    78                 List<ComputingNode> avNodes = filterNodes(nodes, task); 
     77                List<Node> nodes = resourceManager.getNodes(); 
     78                List<Node> avNodes = filterNodes(nodes, task); 
    7979                if(avNodes.size() == 0) 
    8080                        return null; 
    81                 ComputingNode node = randomNode(avNodes); 
     81                Node node = randomNode(avNodes); 
    8282                if(node.getStatus() == ResourceStatus.UNAVAILABLE) { 
    8383                        node.getPowerInterface().setPowerState(StandardPowerStateName.ON); 
    … …  
    113113        } 
    114114         
    115         private List<ComputingNode> filterNodes(List<ComputingNode> nodes, TaskInterface<?> task){ 
    116                 List<ComputingNode> filteredNodes = new ArrayList<ComputingNode>(); 
    117                 for (ComputingNode node : nodes) { 
     115        private List<Node> filterNodes(List<Node> nodes, TaskInterface<?> task){ 
     116                List<Node> filteredNodes = new ArrayList<Node>(); 
     117                for (Node node : nodes) { 
    118118                        int cpuRequest; 
    119119                        try { 
    … …  
    156156        } 
    157157         
    158         private ComputingNode randomNode(List<ComputingNode> nodes){ 
     158        private Node randomNode(List<Node> nodes){ 
    159159                return nodes.get(rand.nextInt(nodes.size())); 
    160160        } 
    161161         
    162         private void turnOffIdleNodes(List<ComputingNode> nodes){ 
    163                 for(ComputingNode node : nodes){ 
     162        private void turnOffIdleNodes(List<Node> nodes){ 
     163                for(Node node : nodes){ 
    164164                        Processor proc = node.getProcessors().get(0); 
    165165                        int freeCores = 0; 

  • DCWoRMS/branches/coolemall/src/test/drs_tst/recs/plugins/scheduling/RecsExclusivenessRandomSP.java

    r1120 r1247  
    1414import schedframe.events.scheduling.SchedulingEvent; 
    1515import schedframe.resources.ResourceStatus; 
    16 import schedframe.resources.computing.ComputingNode; 
     16import schedframe.resources.computing.Node; 
    1717import schedframe.resources.computing.ComputingResource; 
    1818import schedframe.resources.computing.Core; 
    … …  
    7373                Map<ResourceUnitName, ResourceUnit> map = new HashMap<ResourceUnitName, ResourceUnit>(); 
    7474                 
    75                 List<ComputingNode> nodes = resourceManager.getComputingNodes(); 
    76                 List<ComputingNode> avNodes = filterNodes(nodes, task); 
     75                List<Node> nodes = resourceManager.getNodes(); 
     76                List<Node> avNodes = filterNodes(nodes, task); 
    7777                if(avNodes.size() == 0) 
    7878                        return null; 
    79                 ComputingNode node = randomNode(avNodes); 
     79                Node node = randomNode(avNodes); 
    8080                int cpuRequest; 
    8181                try { 
    … …  
    108108        } 
    109109         
    110         private List<ComputingNode> filterNodes(List<ComputingNode> nodes, TaskInterface<?> task){ 
    111                 List<ComputingNode> filteredNodes = new ArrayList<ComputingNode>(); 
    112                 for (ComputingNode node : nodes) { 
     110        private List<Node> filterNodes(List<Node> nodes, TaskInterface<?> task){ 
     111                List<Node> filteredNodes = new ArrayList<Node>(); 
     112                for (Node node : nodes) { 
    113113                        int cpuRequest; 
    114114                        try { 
    … …  
    152152        } 
    153153         
    154         private ComputingNode randomNode(List<ComputingNode> nodes){ 
     154        private Node randomNode(List<Node> nodes){ 
    155155                return nodes.get(rand.nextInt(nodes.size())); 
    156156        } 

  • DCWoRMS/branches/coolemall/src/test/drs_tst/recs/plugins/scheduling/RecsSP.java

    r1120 r1247  
    77import java.util.ResourceBundle; 
    88 
    9 import schedframe.resources.computing.ComputingNode; 
     9import schedframe.resources.computing.Node; 
    1010import schedframe.scheduling.tasks.TaskInterface; 
    1111import test.drs_tst.recs.utils.AppType; 
    … …  
    2727        } 
    2828         
    29         protected String createExecutivenessQuery(TaskInterface<?> task, ComputingNode node) { 
     29        protected String createExecutivenessQuery(TaskInterface<?> task, Node node) { 
    3030                Executable exec = (Executable)task; 
    3131                String query = getApplicationType(exec) + "." + getNodeCategory(node); 
    … …  
    3838        } 
    3939         
    40         private String getNodeCategory(ComputingNode node){ 
     40        private String getNodeCategory(Node node){ 
    4141                return node.getCategory(); 
    4242        } 

  • DCWoRMS/branches/coolemall/src/test/drs_tst/recs/plugins/scheduling/old/RecsExclusivenessDFSSP.java

    r1120 r1247  
    1111import schedframe.events.scheduling.SchedulingEvent; 
    1212import schedframe.resources.ResourceStatus; 
    13 import schedframe.resources.computing.ComputingNode; 
     13import schedframe.resources.computing.Node; 
    1414import schedframe.resources.computing.ComputingResource; 
    1515import schedframe.resources.computing.Core; 
    … …  
    7373                Map<ResourceUnitName, ResourceUnit> map = new HashMap<ResourceUnitName, ResourceUnit>(); 
    7474                 
    75                 List<ComputingNode> nodes = resourceManager.getComputingNodes(); 
    76                 List<ComputingNode> avNodes = filterNodes(nodes, task); 
     75                List<Node> nodes = resourceManager.getNodes(); 
     76                List<Node> avNodes = filterNodes(nodes, task); 
    7777                if(avNodes.size() == 0) 
    7878                        return null; 
    79                 ComputingNode node = randomNode(avNodes); 
     79                Node node = randomNode(avNodes); 
    8080 
    8181                int cpuRequest; 
    … …  
    108108        } 
    109109         
    110         private List<ComputingNode> filterNodes(List<ComputingNode> nodes, TaskInterface<?> task){ 
    111                 List<ComputingNode> filteredNodes = new ArrayList<ComputingNode>(); 
    112                 for (ComputingNode node : nodes) { 
     110        private List<Node> filterNodes(List<Node> nodes, TaskInterface<?> task){ 
     111                List<Node> filteredNodes = new ArrayList<Node>(); 
     112                for (Node node : nodes) { 
    113113                        int cpuRequest; 
    114114                        try { 
    … …  
    141141        } 
    142142         
    143         private ComputingNode randomNode(List<ComputingNode> nodes){ 
     143        private Node randomNode(List<Node> nodes){ 
    144144                return nodes.get(rand.nextInt(nodes.size())); 
    145145        } 

  • DCWoRMS/branches/coolemall/src/test/drs_tst/recs/plugins/scheduling/old/RecsExclusivenessFirstSP.java

    r1120 r1247  
    1010import schedframe.events.scheduling.SchedulingEvent; 
    1111import schedframe.resources.ResourceStatus; 
    12 import schedframe.resources.computing.ComputingNode; 
     12import schedframe.resources.computing.Node; 
    1313import schedframe.resources.computing.ComputingResource; 
    1414import schedframe.resources.computing.Core; 
    … …  
    6767 
    6868                Map<ResourceUnitName, ResourceUnit> map; 
    69                 List<ComputingNode> nodes = resourceManager.getComputingNodes(); 
    70                 for (ComputingNode node : nodes) { 
     69                List<Node> nodes = resourceManager.getNodes(); 
     70                for (Node node : nodes) { 
    7171                        int cpuRequest; 
    7272                        try { 

  • DCWoRMS/branches/coolemall/src/test/drs_tst/recs/plugins/scheduling/old/RecsExclusivenessNodePowManSP.java

    r1120 r1247  
    1010import schedframe.events.scheduling.SchedulingEvent; 
    1111import schedframe.resources.ResourceStatus; 
    12 import schedframe.resources.computing.ComputingNode; 
     12import schedframe.resources.computing.Node; 
    1313import schedframe.resources.computing.ComputingResource; 
    1414import schedframe.resources.computing.Core; 
    … …  
    5555                                                addToSchedulingPlan(plan, task, choosenResources); 
    5656                                        } else { 
    57                                                 if(harnessIdleNodesToWork(task, resourceManager.getComputingNodes())) 
     57                                                if(harnessIdleNodesToWork(task, resourceManager.getNodes())) 
    5858                                                        i--; 
    5959                                        } 
    6060                                } 
    6161                        } 
    62                         turnOffIdleNodes(resourceManager.getComputingNodes()); 
     62                        turnOffIdleNodes(resourceManager.getNodes()); 
    6363                        break; 
    6464                } 
    … …  
    7070                Map<ResourceUnitName, ResourceUnit> map = new HashMap<ResourceUnitName, ResourceUnit>(); 
    7171                 
    72                 List<ComputingNode> nodes = resourceManager.getComputingNodes(); 
    73                 List<ComputingNode> avNodes = filterNodes(nodes, task); 
     72                List<Node> nodes = resourceManager.getNodes(); 
     73                List<Node> avNodes = filterNodes(nodes, task); 
    7474                if(avNodes.size() == 0) 
    7575                        return null; 
    7676 
    77                 for(ComputingNode node: avNodes){ 
     77                for(Node node: avNodes){ 
    7878                        int cpuRequest; 
    7979                        try { 
    … …  
    105105        } 
    106106 
    107         private void turnOffIdleNodes(List<ComputingNode> nodes){ 
    108                 for(ComputingNode node : nodes){ 
     107        private void turnOffIdleNodes(List<Node> nodes){ 
     108                for(Node node : nodes){ 
    109109                        Processor proc = node.getProcessors().get(0); 
    110110                        int freeCores = 0; 
    … …  
    120120        } 
    121121         
    122         private boolean harnessIdleNodesToWork(TaskInterface<?> task, List<ComputingNode> nodes){ 
     122        private boolean harnessIdleNodesToWork(TaskInterface<?> task, List<Node> nodes){ 
    123123 
    124124                int cpuRequest; 
    … …  
    129129                } 
    130130                for (int i = 0; i < nodes.size(); i++) { 
    131                         ComputingNode node = nodes.get(i); 
     131                        Node node = nodes.get(i); 
    132132                        if(node.getPowerInterface().getPowerState() == StandardPowerStateName.OFF){ 
    133133 
    … …  
    144144 
    145145         
    146         private List<ComputingNode> filterNodes(List<ComputingNode> nodes, TaskInterface<?> task){ 
    147                 List<ComputingNode> filteredNodes = new ArrayList<ComputingNode>(); 
    148                 for (ComputingNode node : nodes) { 
     146        private List<Node> filterNodes(List<Node> nodes, TaskInterface<?> task){ 
     147                List<Node> filteredNodes = new ArrayList<Node>(); 
     148                for (Node node : nodes) { 
    149149                        int cpuRequest; 
    150150                        try { 

  • DCWoRMS/branches/coolemall/src/test/drs_tst/recs/plugins/timeestimation/RecsTimeEstimationPlugin.java

    r1120 r1247  
    1010 
    1111import schedframe.events.scheduling.SchedulingEvent; 
    12 import schedframe.resources.computing.ComputingNode; 
     12import schedframe.resources.computing.Node; 
    1313import schedframe.resources.computing.Core; 
    1414import schedframe.resources.computing.Processor; 
    … …  
    7575                //System.out.println("rccc"); 
    7676                ProcessingElements pe = (ProcessingElements) peUnit; 
    77                 if(pe.get(0) instanceof ComputingNode) 
    78                         return ((ComputingNode)pe.get(0)).getCategory(); 
     77                if(pe.get(0) instanceof Node) 
     78                        return ((Node)pe.get(0)).getCategory(); 
    7979                Core core = (Core)pe.get(0); 
    8080                return core.getParent().getParent().getCategory(); 
    … …  
    8383        private int getFrequency(PEUnit peUnit){ 
    8484                ProcessingElements pe = (ProcessingElements) peUnit; 
    85                 if(pe.get(0) instanceof ComputingNode) 
    86                         return Double.valueOf(((ComputingNode)pe.get(0)).getProcessors().get(0).getPowerInterface().getFrequency()).intValue(); 
     85                if(pe.get(0) instanceof Node) 
     86                        return Double.valueOf(((Node)pe.get(0)).getProcessors().get(0).getPowerInterface().getFrequency()).intValue(); 
    8787                Core core = (Core)pe.get(0); 
    8888                Processor proc = (Processor) core.getParent(); 
    … …  
    9898                try { 
    9999                        cpuReq = task.getCpuCntRequest(); 
    100                         cpuReq = ((ComputingNode)pe.get(0)).getProcessors().get(0).getCores().size(); 
     100                        cpuReq = ((Node)pe.get(0)).getProcessors().get(0).getCores().size(); 
    101101                } catch (NoSuchFieldException e) { 
    102102                                cpuReq = 1; 

  • DCWoRMS/branches/coolemall/src/test/drs_tst/recs/utils/DAO.java

    r1120 r1247  
    77import java.util.ResourceBundle; 
    88 
    9 import schedframe.resources.computing.ComputingNode; 
     9import schedframe.resources.computing.Node; 
    1010import schedframe.resources.computing.Processor; 
    1111import schedframe.scheduling.tasks.TaskInterface; 
    … …  
    2020        private TaskToApp taskToApp = new TaskToApp(); 
    2121 
    22         protected String createQuery(TaskInterface<?> task, ComputingNode node) { 
     22        protected String createQuery(TaskInterface<?> task, Node node) { 
    2323                String query; 
    2424                query = getApplicationType(task) + "." + getNodeCategory(node) + "." + getFrequency(node) + "." + getCoreCnt(task); 
    … …  
    3131        } 
    3232         
    33         private String getNodeCategory(ComputingNode node){ 
     33        private String getNodeCategory(Node node){ 
    3434 
    3535                return node.getCategory(); 
    3636        } 
    3737         
    38         private int getFrequency(ComputingNode node){ 
     38        private int getFrequency(Node node){ 
    3939                Processor proc = (Processor) node.getProcessors().get(0); 
    4040                double freq = proc.getPowerInterface().getFrequency(); 
Note: See TracChangeset for help on using the changeset viewer.