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

Legend:

Unmodified
Added
Removed

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