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

Legend:

Unmodified
Added
Removed
  • 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.