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

Legend:

Unmodified
Added
Removed

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