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

Legend:

Unmodified
Added
Removed

  • DCWoRMS/branches/coolemall/src/test/drs_tst/recs/plugins/energy/AmdNodeEEP.java

    r1243 r1247  
    44import java.io.IOException; 
    55 
    6 import schedframe.resources.computing.ComputingNode; 
     6import schedframe.resources.computing.Node; 
    77import schedframe.resources.computing.Processor; 
    88import schedframe.resources.computing.profiles.energy.EnergyEvent; 
    … …  
    1818                double powerConsumption = 0; 
    1919                 
    20                 ComputingNode node = (ComputingNode) resource; 
     20                Node node = (Node) resource; 
    2121                try { 
    2222                        if(jobRegistry.getRunningTasks().size() > 0) { 

  • DCWoRMS/branches/coolemall/src/test/drs_tst/recs/plugins/energy/AtomD510NodeEEP.java

    r1243 r1247  
    44import java.io.IOException; 
    55 
    6 import schedframe.resources.computing.ComputingNode; 
     6import schedframe.resources.computing.Node; 
    77import schedframe.resources.computing.Processor; 
    88import schedframe.resources.computing.profiles.energy.EnergyEvent; 
    … …  
    1515                        PhysicalResource resource) { 
    1616                double powerConsumption = 0; 
    17                 ComputingNode node = (ComputingNode) resource; 
     17                Node node = (Node) resource; 
    1818                try { 
    1919                        if(jobRegistry.getRunningTasks().size() > 0) { 

  • DCWoRMS/branches/coolemall/src/test/drs_tst/recs/plugins/energy/AtomZ510NodeEEP.java

    r1243 r1247  
    44import java.io.IOException; 
    55 
    6 import schedframe.resources.computing.ComputingNode; 
     6import schedframe.resources.computing.Node; 
    77import schedframe.resources.computing.Processor; 
    88import schedframe.resources.computing.profiles.energy.EnergyEvent; 
    … …  
    1717                        PhysicalResource resource) { 
    1818                double powerConsumption = 0; 
    19                 ComputingNode node = (ComputingNode) resource; 
     19                Node node = (Node) resource; 
    2020                try { 
    2121                        if(jobRegistry.getRunningTasks().size() > 0) { 

  • DCWoRMS/branches/coolemall/src/test/drs_tst/recs/plugins/energy/IntelNodeEEP.java

    r1243 r1247  
    44import java.io.IOException; 
    55 
    6 import schedframe.resources.computing.ComputingNode; 
     6import schedframe.resources.computing.Node; 
    77import schedframe.resources.computing.Processor; 
    88import schedframe.resources.computing.profiles.energy.EnergyEvent; 
    … …  
    1515                        PhysicalResource resource) { 
    1616                double powerConsumption = 0; 
    17                 ComputingNode node = (ComputingNode) resource; 
     17                Node node = (Node) resource; 
    1818                 
    1919                try { 

  • DCWoRMS/branches/coolemall/src/test/drs_tst/recs/plugins/energy/RecsNodeBaseEEP.java

    r1245 r1247  
    99import java.util.ResourceBundle; 
    1010 
    11 import schedframe.resources.computing.ComputingNode; 
     11import schedframe.resources.computing.Node; 
    1212import schedframe.resources.computing.Core; 
    1313import schedframe.resources.computing.Processor; 
    … …  
    5454                 
    5555                ProcessingElements pe = (ProcessingElements) peUnit; 
    56                 if(pe.get(0) instanceof ComputingNode) 
    57                         return ((ComputingNode)pe.get(0)).getCategory(); 
     56                if(pe.get(0) instanceof Node) 
     57                        return ((Node)pe.get(0)).getCategory(); 
    5858                Core core = (Core)pe.get(0); 
    5959                return core.getParent().getParent().getCategory(); 
    … …  
    6262        private int getFrequency(PEUnit peUnit){ 
    6363                ProcessingElements pe = (ProcessingElements) peUnit; 
    64                 if(pe.get(0) instanceof ComputingNode) 
    65                         return Double.valueOf(((ComputingNode)pe.get(0)).getProcessors().get(0).getPowerInterface().getFrequency()).intValue(); 
     64                if(pe.get(0) instanceof Node) 
     65                        return Double.valueOf(((Node)pe.get(0)).getProcessors().get(0).getPowerInterface().getFrequency()).intValue(); 
    6666                Core core = (Core)pe.get(0); 
    6767                Processor proc = (Processor) core.getParent(); 

  • DCWoRMS/branches/coolemall/src/test/drs_tst/recs/plugins/scheduling/RecsExclusivenessDFSSP.java

    r1245 r1247  
    1414import schedframe.events.scheduling.SchedulingEvent; 
    1515import schedframe.resources.ResourceStatus; 
    16 import schedframe.resources.computing.ComputingNode; 
     16import schedframe.resources.computing.Node; 
    1717import schedframe.resources.computing.ComputingResource; 
    1818import schedframe.resources.computing.Core; 
    … …  
    7575                Map<ResourceUnitName, ResourceUnit> map = new HashMap<ResourceUnitName, ResourceUnit>(); 
    7676                 
    77                 List<ComputingNode> nodes = resourceManager.getComputingNodes(); 
    78                 List<ComputingNode> avNodes = filterNodes(nodes, task); 
     77                List<Node> nodes = resourceManager.getNodes(); 
     78                List<Node> avNodes = filterNodes(nodes, task); 
    7979                if(avNodes.size() == 0) 
    8080                        return null; 
    81                 ComputingNode node = randomNode(avNodes); 
     81                Node node = randomNode(avNodes); 
    8282 
    8383                int cpuRequest; 
    … …  
    111111        } 
    112112         
    113         private List<ComputingNode> filterNodes(List<ComputingNode> nodes, TaskInterface<?> task){ 
    114                 List<ComputingNode> filteredNodes = new ArrayList<ComputingNode>(); 
    115                 for (ComputingNode node : nodes) { 
     113        private List<Node> filterNodes(List<Node> nodes, TaskInterface<?> task){ 
     114                List<Node> filteredNodes = new ArrayList<Node>(); 
     115                for (Node node : nodes) { 
    116116                        int cpuRequest; 
    117117                        try { 
    … …  
    154154        } 
    155155         
    156         private ComputingNode randomNode(List<ComputingNode> nodes){ 
     156        private Node randomNode(List<Node> nodes){ 
    157157                return nodes.get(rand.nextInt(nodes.size())); 
    158158        } 

  • DCWoRMS/branches/coolemall/src/test/drs_tst/recs/plugins/scheduling/RecsExclusivenessEnOptDFSSP.java

    r1245 r1247  
    1818import schedframe.events.scheduling.SchedulingEvent; 
    1919import schedframe.resources.ResourceStatus; 
    20 import schedframe.resources.computing.ComputingNode; 
     20import schedframe.resources.computing.Node; 
    2121import schedframe.resources.computing.ComputingResource; 
    2222import schedframe.resources.computing.Core; 
    … …  
    8585 
    8686                Map<ResourceUnitName, ResourceUnit> map; 
    87                 List<ComputingNode> nodes = resourceManager.getComputingNodes(); 
     87                List<Node> nodes = resourceManager.getNodes(); 
    8888                Collections.sort(nodes, new EnergyComparator(task)); 
    8989                //System.out.println("*****"); 
    90                 for (ComputingNode node : nodes) { 
     90                for (Node node : nodes) { 
    9191                        //System.out.println(node.getCategory()); 
    9292                        int cpuRequest; 
    … …  
    153153 
    154154         
    155         protected String createQuery(TaskInterface<?> task, ComputingNode node) { 
     155        protected String createQuery(TaskInterface<?> task, Node node) { 
    156156                String query; 
    157157                query = getApplicationType(task) + "." + getNodeCategory(node) + "." + getFrequency(node) + "." + getCoreCnt(task); 
    … …  
    164164        } 
    165165         
    166         private String getNodeCategory(ComputingNode node){ 
     166        private String getNodeCategory(Node node){ 
    167167 
    168168                return node.getCategory(); 
    169169        } 
    170170         
    171         private int getFrequency(ComputingNode node){ 
     171        private int getFrequency(Node node){ 
    172172                Processor proc = (Processor) node.getProcessors().get(0); 
    173173                double freq = proc.getPowerInterface().getFrequency(); 
    … …  
    208208                return timeBundle; 
    209209        } 
    210         class EnergyComparator implements Comparator<ComputingNode>{ 
     210        class EnergyComparator implements Comparator<Node>{ 
    211211                private TaskInterface<?> task; 
    212212                 
    … …  
    215215                } 
    216216                 
    217             public int compare(ComputingNode node1, ComputingNode node2){     
     217            public int compare(Node node1, Node node2){     
    218218                double node1EU = Double.MAX_VALUE; 
    219219                double node2EU = Double.MAX_VALUE; 

  • DCWoRMS/branches/coolemall/src/test/drs_tst/recs/plugins/scheduling/RecsExclusivenessEnOptNodePowManSP.java

    r1120 r1247  
    1818import schedframe.events.scheduling.SchedulingEvent; 
    1919import schedframe.resources.ResourceStatus; 
    20 import schedframe.resources.computing.ComputingNode; 
     20import schedframe.resources.computing.Node; 
    2121import schedframe.resources.computing.ComputingResource; 
    2222import schedframe.resources.computing.Core; 
    … …  
    7676                                } 
    7777                        } 
    78                         turnOffIdleNodes(resourceManager.getComputingNodes()); 
     78                        turnOffIdleNodes(resourceManager.getNodes()); 
    7979                        break; 
    8080                } 
    … …  
    8686 
    8787                Map<ResourceUnitName, ResourceUnit> map; 
    88                 List<ComputingNode> nodes = resourceManager.getComputingNodes(); 
     88                List<Node> nodes = resourceManager.getNodes(); 
    8989                Collections.sort(nodes, new EnergyComparator(task)); 
    90                 for (ComputingNode node : nodes) { 
     90                for (Node node : nodes) { 
    9191                        int cpuRequest; 
    9292                        try { 
    … …  
    156156 
    157157         
    158         protected String createQuery(TaskInterface<?> task, ComputingNode node) { 
     158        protected String createQuery(TaskInterface<?> task, Node node) { 
    159159                String query; 
    160160                query = getApplicationType(task) + "." + getNodeCategory(node) + "." + getFrequency(node) + "." + getCoreCnt(task); 
    … …  
    167167        } 
    168168         
    169         private String getNodeCategory(ComputingNode node){ 
     169        private String getNodeCategory(Node node){ 
    170170 
    171171                return node.getCategory(); 
    172172        } 
    173173         
    174         private int getFrequency(ComputingNode node){ 
     174        private int getFrequency(Node node){ 
    175175                Processor proc = (Processor) node.getProcessors().get(0); 
    176176                double freq = proc.getPowerInterface().getFrequency(); 
    … …  
    211211                return timeBundle; 
    212212        } 
    213         class EnergyComparator implements Comparator<ComputingNode>{ 
     213        class EnergyComparator implements Comparator<Node>{ 
    214214                private TaskInterface<?> task; 
    215215                 
    … …  
    218218                } 
    219219                 
    220             public int compare(ComputingNode node1, ComputingNode node2){     
     220            public int compare(Node node1, Node node2){     
    221221                double node1EU = Double.MAX_VALUE; 
    222222                double node2EU = Double.MAX_VALUE; 
    … …  
    248248        } 
    249249         
    250         private void turnOffIdleNodes(List<ComputingNode> nodes){ 
    251                 for(ComputingNode node : nodes){ 
     250        private void turnOffIdleNodes(List<Node> nodes){ 
     251                for(Node node : nodes){ 
    252252                        Processor proc = node.getProcessors().get(0); 
    253253                        int freeCores = 0; 

  • DCWoRMS/branches/coolemall/src/test/drs_tst/recs/plugins/scheduling/RecsExclusivenessEnOptSP.java

    r1245 r1247  
    1818import schedframe.events.scheduling.SchedulingEvent; 
    1919import schedframe.resources.ResourceStatus; 
    20 import schedframe.resources.computing.ComputingNode; 
     20import schedframe.resources.computing.Node; 
    2121import schedframe.resources.computing.ComputingResource; 
    2222import schedframe.resources.computing.Core; 
    … …  
    8383 
    8484                Map<ResourceUnitName, ResourceUnit> map; 
    85                 List<ComputingNode> nodes = resourceManager.getComputingNodes(); 
     85                List<Node> nodes = resourceManager.getNodes(); 
    8686                Collections.sort(nodes, new EnergyComparator(task)); 
    8787                //System.out.println("*****"); 
    88                 for (ComputingNode node : nodes) { 
     88                for (Node node : nodes) { 
    8989                        //System.out.println(node.getCategory()); 
    9090                        int cpuRequest; 
    … …  
    151151 
    152152         
    153         protected String createQuery(TaskInterface<?> task, ComputingNode node) { 
     153        protected String createQuery(TaskInterface<?> task, Node node) { 
    154154                String query; 
    155155                query = getApplicationType(task) + "." + getNodeCategory(node) + "." + getFrequency(node) + "." + getCoreCnt(task); 
    … …  
    162162        } 
    163163         
    164         private String getNodeCategory(ComputingNode node){ 
     164        private String getNodeCategory(Node node){ 
    165165 
    166166                return node.getCategory(); 
    167167        } 
    168168         
    169         private int getFrequency(ComputingNode node){ 
     169        private int getFrequency(Node node){ 
    170170                Processor proc = (Processor) node.getProcessors().get(0); 
    171171                double freq = proc.getPowerInterface().getFrequency(); 
    … …  
    207207                return timeBundle; 
    208208        } 
    209         class EnergyComparator implements Comparator<ComputingNode>{ 
     209        class EnergyComparator implements Comparator<Node>{ 
    210210                private TaskInterface<?> task; 
    211211                 
    … …  
    214214                } 
    215215                 
    216             public int compare(ComputingNode node1, ComputingNode node2){     
     216            public int compare(Node node1, Node node2){     
    217217                double node1EU = Double.MAX_VALUE; 
    218218                double node2EU = Double.MAX_VALUE; 

  • DCWoRMS/branches/coolemall/src/test/drs_tst/recs/plugins/scheduling/RecsExclusivenessRandomNodePowManSP.java

    r1120 r1247  
    1414import schedframe.events.scheduling.SchedulingEvent; 
    1515import schedframe.resources.ResourceStatus; 
    16 import schedframe.resources.computing.ComputingNode; 
     16import schedframe.resources.computing.Node; 
    1717import schedframe.resources.computing.ComputingResource; 
    1818import schedframe.resources.computing.Core; 
    … …  
    6464                                } 
    6565                        } 
    66                         turnOffIdleNodes(resourceManager.getComputingNodes()); 
     66                        turnOffIdleNodes(resourceManager.getNodes()); 
    6767                        break; 
    6868                } 
    … …  
    7575                Map<ResourceUnitName, ResourceUnit> map = new HashMap<ResourceUnitName, ResourceUnit>(); 
    7676                 
    77                 List<ComputingNode> nodes = resourceManager.getComputingNodes(); 
    78                 List<ComputingNode> avNodes = filterNodes(nodes, task); 
     77                List<Node> nodes = resourceManager.getNodes(); 
     78                List<Node> avNodes = filterNodes(nodes, task); 
    7979                if(avNodes.size() == 0) 
    8080                        return null; 
    81                 ComputingNode node = randomNode(avNodes); 
     81                Node node = randomNode(avNodes); 
    8282                if(node.getStatus() == ResourceStatus.UNAVAILABLE) { 
    8383                        node.getPowerInterface().setPowerState(StandardPowerStateName.ON); 
    … …  
    113113        } 
    114114         
    115         private List<ComputingNode> filterNodes(List<ComputingNode> nodes, TaskInterface<?> task){ 
    116                 List<ComputingNode> filteredNodes = new ArrayList<ComputingNode>(); 
    117                 for (ComputingNode node : nodes) { 
     115        private List<Node> filterNodes(List<Node> nodes, TaskInterface<?> task){ 
     116                List<Node> filteredNodes = new ArrayList<Node>(); 
     117                for (Node node : nodes) { 
    118118                        int cpuRequest; 
    119119                        try { 
    … …  
    156156        } 
    157157         
    158         private ComputingNode randomNode(List<ComputingNode> nodes){ 
     158        private Node randomNode(List<Node> nodes){ 
    159159                return nodes.get(rand.nextInt(nodes.size())); 
    160160        } 
    161161         
    162         private void turnOffIdleNodes(List<ComputingNode> nodes){ 
    163                 for(ComputingNode node : nodes){ 
     162        private void turnOffIdleNodes(List<Node> nodes){ 
     163                for(Node node : nodes){ 
    164164                        Processor proc = node.getProcessors().get(0); 
    165165                        int freeCores = 0; 

  • DCWoRMS/branches/coolemall/src/test/drs_tst/recs/plugins/scheduling/RecsExclusivenessRandomSP.java

    r1120 r1247  
    1414import schedframe.events.scheduling.SchedulingEvent; 
    1515import schedframe.resources.ResourceStatus; 
    16 import schedframe.resources.computing.ComputingNode; 
     16import schedframe.resources.computing.Node; 
    1717import schedframe.resources.computing.ComputingResource; 
    1818import schedframe.resources.computing.Core; 
    … …  
    7373                Map<ResourceUnitName, ResourceUnit> map = new HashMap<ResourceUnitName, ResourceUnit>(); 
    7474                 
    75                 List<ComputingNode> nodes = resourceManager.getComputingNodes(); 
    76                 List<ComputingNode> avNodes = filterNodes(nodes, task); 
     75                List<Node> nodes = resourceManager.getNodes(); 
     76                List<Node> avNodes = filterNodes(nodes, task); 
    7777                if(avNodes.size() == 0) 
    7878                        return null; 
    79                 ComputingNode node = randomNode(avNodes); 
     79                Node node = randomNode(avNodes); 
    8080                int cpuRequest; 
    8181                try { 
    … …  
    108108        } 
    109109         
    110         private List<ComputingNode> filterNodes(List<ComputingNode> nodes, TaskInterface<?> task){ 
    111                 List<ComputingNode> filteredNodes = new ArrayList<ComputingNode>(); 
    112                 for (ComputingNode node : nodes) { 
     110        private List<Node> filterNodes(List<Node> nodes, TaskInterface<?> task){ 
     111                List<Node> filteredNodes = new ArrayList<Node>(); 
     112                for (Node node : nodes) { 
    113113                        int cpuRequest; 
    114114                        try { 
    … …  
    152152        } 
    153153         
    154         private ComputingNode randomNode(List<ComputingNode> nodes){ 
     154        private Node randomNode(List<Node> nodes){ 
    155155                return nodes.get(rand.nextInt(nodes.size())); 
    156156        } 

  • DCWoRMS/branches/coolemall/src/test/drs_tst/recs/plugins/scheduling/RecsSP.java

    r1120 r1247  
    77import java.util.ResourceBundle; 
    88 
    9 import schedframe.resources.computing.ComputingNode; 
     9import schedframe.resources.computing.Node; 
    1010import schedframe.scheduling.tasks.TaskInterface; 
    1111import test.drs_tst.recs.utils.AppType; 
    … …  
    2727        } 
    2828         
    29         protected String createExecutivenessQuery(TaskInterface<?> task, ComputingNode node) { 
     29        protected String createExecutivenessQuery(TaskInterface<?> task, Node node) { 
    3030                Executable exec = (Executable)task; 
    3131                String query = getApplicationType(exec) + "." + getNodeCategory(node); 
    … …  
    3838        } 
    3939         
    40         private String getNodeCategory(ComputingNode node){ 
     40        private String getNodeCategory(Node node){ 
    4141                return node.getCategory(); 
    4242        } 

  • DCWoRMS/branches/coolemall/src/test/drs_tst/recs/plugins/scheduling/old/RecsExclusivenessDFSSP.java

    r1120 r1247  
    1111import schedframe.events.scheduling.SchedulingEvent; 
    1212import schedframe.resources.ResourceStatus; 
    13 import schedframe.resources.computing.ComputingNode; 
     13import schedframe.resources.computing.Node; 
    1414import schedframe.resources.computing.ComputingResource; 
    1515import schedframe.resources.computing.Core; 
    … …  
    7373                Map<ResourceUnitName, ResourceUnit> map = new HashMap<ResourceUnitName, ResourceUnit>(); 
    7474                 
    75                 List<ComputingNode> nodes = resourceManager.getComputingNodes(); 
    76                 List<ComputingNode> avNodes = filterNodes(nodes, task); 
     75                List<Node> nodes = resourceManager.getNodes(); 
     76                List<Node> avNodes = filterNodes(nodes, task); 
    7777                if(avNodes.size() == 0) 
    7878                        return null; 
    79                 ComputingNode node = randomNode(avNodes); 
     79                Node node = randomNode(avNodes); 
    8080 
    8181                int cpuRequest; 
    … …  
    108108        } 
    109109         
    110         private List<ComputingNode> filterNodes(List<ComputingNode> nodes, TaskInterface<?> task){ 
    111                 List<ComputingNode> filteredNodes = new ArrayList<ComputingNode>(); 
    112                 for (ComputingNode node : nodes) { 
     110        private List<Node> filterNodes(List<Node> nodes, TaskInterface<?> task){ 
     111                List<Node> filteredNodes = new ArrayList<Node>(); 
     112                for (Node node : nodes) { 
    113113                        int cpuRequest; 
    114114                        try { 
    … …  
    141141        } 
    142142         
    143         private ComputingNode randomNode(List<ComputingNode> nodes){ 
     143        private Node randomNode(List<Node> nodes){ 
    144144                return nodes.get(rand.nextInt(nodes.size())); 
    145145        } 

  • DCWoRMS/branches/coolemall/src/test/drs_tst/recs/plugins/scheduling/old/RecsExclusivenessFirstSP.java

    r1120 r1247  
    1010import schedframe.events.scheduling.SchedulingEvent; 
    1111import schedframe.resources.ResourceStatus; 
    12 import schedframe.resources.computing.ComputingNode; 
     12import schedframe.resources.computing.Node; 
    1313import schedframe.resources.computing.ComputingResource; 
    1414import schedframe.resources.computing.Core; 
    … …  
    6767 
    6868                Map<ResourceUnitName, ResourceUnit> map; 
    69                 List<ComputingNode> nodes = resourceManager.getComputingNodes(); 
    70                 for (ComputingNode node : nodes) { 
     69                List<Node> nodes = resourceManager.getNodes(); 
     70                for (Node node : nodes) { 
    7171                        int cpuRequest; 
    7272                        try { 

  • DCWoRMS/branches/coolemall/src/test/drs_tst/recs/plugins/scheduling/old/RecsExclusivenessNodePowManSP.java

    r1120 r1247  
    1010import schedframe.events.scheduling.SchedulingEvent; 
    1111import schedframe.resources.ResourceStatus; 
    12 import schedframe.resources.computing.ComputingNode; 
     12import schedframe.resources.computing.Node; 
    1313import schedframe.resources.computing.ComputingResource; 
    1414import schedframe.resources.computing.Core; 
    … …  
    5555                                                addToSchedulingPlan(plan, task, choosenResources); 
    5656                                        } else { 
    57                                                 if(harnessIdleNodesToWork(task, resourceManager.getComputingNodes())) 
     57                                                if(harnessIdleNodesToWork(task, resourceManager.getNodes())) 
    5858                                                        i--; 
    5959                                        } 
    6060                                } 
    6161                        } 
    62                         turnOffIdleNodes(resourceManager.getComputingNodes()); 
     62                        turnOffIdleNodes(resourceManager.getNodes()); 
    6363                        break; 
    6464                } 
    … …  
    7070                Map<ResourceUnitName, ResourceUnit> map = new HashMap<ResourceUnitName, ResourceUnit>(); 
    7171                 
    72                 List<ComputingNode> nodes = resourceManager.getComputingNodes(); 
    73                 List<ComputingNode> avNodes = filterNodes(nodes, task); 
     72                List<Node> nodes = resourceManager.getNodes(); 
     73                List<Node> avNodes = filterNodes(nodes, task); 
    7474                if(avNodes.size() == 0) 
    7575                        return null; 
    7676 
    77                 for(ComputingNode node: avNodes){ 
     77                for(Node node: avNodes){ 
    7878                        int cpuRequest; 
    7979                        try { 
    … …  
    105105        } 
    106106 
    107         private void turnOffIdleNodes(List<ComputingNode> nodes){ 
    108                 for(ComputingNode node : nodes){ 
     107        private void turnOffIdleNodes(List<Node> nodes){ 
     108                for(Node node : nodes){ 
    109109                        Processor proc = node.getProcessors().get(0); 
    110110                        int freeCores = 0; 
    … …  
    120120        } 
    121121         
    122         private boolean harnessIdleNodesToWork(TaskInterface<?> task, List<ComputingNode> nodes){ 
     122        private boolean harnessIdleNodesToWork(TaskInterface<?> task, List<Node> nodes){ 
    123123 
    124124                int cpuRequest; 
    … …  
    129129                } 
    130130                for (int i = 0; i < nodes.size(); i++) { 
    131                         ComputingNode node = nodes.get(i); 
     131                        Node node = nodes.get(i); 
    132132                        if(node.getPowerInterface().getPowerState() == StandardPowerStateName.OFF){ 
    133133 
    … …  
    144144 
    145145         
    146         private List<ComputingNode> filterNodes(List<ComputingNode> nodes, TaskInterface<?> task){ 
    147                 List<ComputingNode> filteredNodes = new ArrayList<ComputingNode>(); 
    148                 for (ComputingNode node : nodes) { 
     146        private List<Node> filterNodes(List<Node> nodes, TaskInterface<?> task){ 
     147                List<Node> filteredNodes = new ArrayList<Node>(); 
     148                for (Node node : nodes) { 
    149149                        int cpuRequest; 
    150150                        try { 

  • DCWoRMS/branches/coolemall/src/test/drs_tst/recs/plugins/timeestimation/RecsTimeEstimationPlugin.java

    r1120 r1247  
    1010 
    1111import schedframe.events.scheduling.SchedulingEvent; 
    12 import schedframe.resources.computing.ComputingNode; 
     12import schedframe.resources.computing.Node; 
    1313import schedframe.resources.computing.Core; 
    1414import schedframe.resources.computing.Processor; 
    … …  
    7575                //System.out.println("rccc"); 
    7676                ProcessingElements pe = (ProcessingElements) peUnit; 
    77                 if(pe.get(0) instanceof ComputingNode) 
    78                         return ((ComputingNode)pe.get(0)).getCategory(); 
     77                if(pe.get(0) instanceof Node) 
     78                        return ((Node)pe.get(0)).getCategory(); 
    7979                Core core = (Core)pe.get(0); 
    8080                return core.getParent().getParent().getCategory(); 
    … …  
    8383        private int getFrequency(PEUnit peUnit){ 
    8484                ProcessingElements pe = (ProcessingElements) peUnit; 
    85                 if(pe.get(0) instanceof ComputingNode) 
    86                         return Double.valueOf(((ComputingNode)pe.get(0)).getProcessors().get(0).getPowerInterface().getFrequency()).intValue(); 
     85                if(pe.get(0) instanceof Node) 
     86                        return Double.valueOf(((Node)pe.get(0)).getProcessors().get(0).getPowerInterface().getFrequency()).intValue(); 
    8787                Core core = (Core)pe.get(0); 
    8888                Processor proc = (Processor) core.getParent(); 
    … …  
    9898                try { 
    9999                        cpuReq = task.getCpuCntRequest(); 
    100                         cpuReq = ((ComputingNode)pe.get(0)).getProcessors().get(0).getCores().size(); 
     100                        cpuReq = ((Node)pe.get(0)).getProcessors().get(0).getCores().size(); 
    101101                } catch (NoSuchFieldException e) { 
    102102                                cpuReq = 1; 

  • DCWoRMS/branches/coolemall/src/test/drs_tst/recs/utils/DAO.java

    r1120 r1247  
    77import java.util.ResourceBundle; 
    88 
    9 import schedframe.resources.computing.ComputingNode; 
     9import schedframe.resources.computing.Node; 
    1010import schedframe.resources.computing.Processor; 
    1111import schedframe.scheduling.tasks.TaskInterface; 
    … …  
    2020        private TaskToApp taskToApp = new TaskToApp(); 
    2121 
    22         protected String createQuery(TaskInterface<?> task, ComputingNode node) { 
     22        protected String createQuery(TaskInterface<?> task, Node node) { 
    2323                String query; 
    2424                query = getApplicationType(task) + "." + getNodeCategory(node) + "." + getFrequency(node) + "." + getCoreCnt(task); 
    … …  
    3131        } 
    3232         
    33         private String getNodeCategory(ComputingNode node){ 
     33        private String getNodeCategory(Node node){ 
    3434 
    3535                return node.getCategory(); 
    3636        } 
    3737         
    38         private int getFrequency(ComputingNode node){ 
     38        private int getFrequency(Node node){ 
    3939                Processor proc = (Processor) node.getProcessors().get(0); 
    4040                double freq = proc.getPowerInterface().getFrequency(); 
Note: See TracChangeset for help on using the changeset viewer.