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

Legend:

Unmodified
Added
Removed

  • 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); 
Note: See TracChangeset for help on using the changeset viewer.