Ignore:
Timestamp:
11/28/13 10:54:54 (11 years ago)
Author:
wojtekp
Message:
 
Location:
DCWoRMS/branches/coolemall/src/test
Files:
48 edited

Legend:

Unmodified
Added
Removed

  • 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.