Ignore:
Timestamp:
11/26/13 11:56:07 (11 years ago)
Author:
wojtekp
Message:
 
Location:
DCWoRMS/branches/coolemall/src/example/energy
Files:
10 added
1 deleted
8 edited
1 moved

Legend:

Unmodified
Added
Removed

  • DCWoRMS/branches/coolemall/src/example/energy/BaseEnergyEstimationPlugin.java

    r751 r1207  
    33import schedframe.Parameters; 
    44import schedframe.PluginConfiguration; 
    5 import schedframe.resources.computing.ComputingResource; 
    65import schedframe.resources.computing.profiles.energy.EnergyEvent; 
    76import schedframe.resources.computing.profiles.energy.power.plugin.EnergyEstimationPlugin; 
     7import schedframe.resources.devices.PhysicalResource; 
    88import schedframe.scheduling.manager.tasks.JobRegistry; 
    99 
    … …  
    1717         
    1818        @Override 
    19         public double estimateAirThroughput(EnergyEvent event, JobRegistry jobRegistry, ComputingResource resource) { 
     19        public double estimateAirThroughput(EnergyEvent event, JobRegistry jobRegistry, PhysicalResource resource) { 
    2020                throw new RuntimeException("Not implemented."); 
    2121        } 
    2222 
    2323        @Override 
    24         public double estimateTemperature(EnergyEvent event, JobRegistry jobRegistry, ComputingResource resource) { 
     24        public double estimateTemperature(EnergyEvent event, JobRegistry jobRegistry, PhysicalResource resource) { 
    2525                throw new RuntimeException("Not implemented."); 
    2626        } 

  • DCWoRMS/branches/coolemall/src/example/energy/DataCenterEnergyEstimationPlugin.java

    r520 r1207  
    22 
    33import schedframe.resources.computing.ComputingNode; 
    4 import schedframe.resources.computing.ComputingResource; 
    54import schedframe.resources.computing.DataCenter; 
    65import schedframe.resources.computing.profiles.energy.EnergyEvent; 
    76import schedframe.resources.computing.profiles.energy.power.PowerUsage; 
     7import schedframe.resources.devices.PhysicalResource; 
    88import schedframe.scheduling.manager.tasks.JobRegistry; 
    99 
    … …  
    1212        @Override 
    1313        public double estimatePowerConsumption(EnergyEvent event, JobRegistry jobRegistry, 
    14                         ComputingResource resource) { 
     14                        PhysicalResource resource) { 
    1515                double power = 0; 
    1616                DataCenter dataCenter = (DataCenter)resource; 

  • DCWoRMS/branches/coolemall/src/example/energy/DefaultEnergyEstimationPlugin.java

    r546 r1207  
    33import schedframe.resources.computing.ComputingResource; 
    44import schedframe.resources.computing.profiles.energy.EnergyEvent; 
     5import schedframe.resources.devices.PhysicalResource; 
    56import schedframe.scheduling.manager.tasks.JobRegistry; 
    67 
    … …  
    910 
    1011 
    11         public double estimatePowerConsumption(EnergyEvent event, JobRegistry jobRegistry, ComputingResource resource) { 
     12        public double estimatePowerConsumption(EnergyEvent event, JobRegistry jobRegistry, PhysicalResource resource) { 
    1213                double powerConsumption = 0; 
    1314                try { 
    … …  
    1718                } 
    1819                 
    19                 powerConsumption = powerConsumption + getChildrenPowerConsumption(resource); 
    20                  
    21                 for(ComputingResource child:resource.getChildren()){ 
    22                         try { 
    23                                 //powerConsumption = powerConsumption + child.getPowerInterface().getRecentPowerUsage().getValue();  
    24                         } catch (Exception e) { 
     20                ComputingResource cr = (ComputingResource) resource; 
     21                powerConsumption = powerConsumption + getChildrenPowerConsumption(cr); 
    2522 
    26                         } 
    27                 } 
    2823                return powerConsumption; 
    2924        } 

  • DCWoRMS/branches/coolemall/src/example/energy/NodeEnergyEstimationPlugin.java

    r532 r1207  
    22 
    33import schedframe.resources.computing.ComputingNode; 
    4 import schedframe.resources.computing.ComputingResource; 
    54import schedframe.resources.computing.Processor; 
    65import schedframe.resources.computing.profiles.energy.EnergyEvent; 
     6import schedframe.resources.devices.Device; 
     7import schedframe.resources.devices.PhysicalResource; 
    78import schedframe.scheduling.manager.tasks.JobRegistry; 
    89 
    9 public class ComputingNodeEnergyEstimationPlugin extends BaseEnergyEstimationPlugin { 
     10public class NodeEnergyEstimationPlugin extends BaseEnergyEstimationPlugin { 
    1011 
    1112        public double estimatePowerConsumption(EnergyEvent event, JobRegistry jobRegistry, 
    12                         ComputingResource resource) { 
     13                        PhysicalResource resource) { 
    1314                double powerConsumption = 0; 
    1415                ComputingNode node = (ComputingNode) resource; 
    … …  
    2223                try { 
    2324                        powerConsumption = powerConsumption + node.getPowerInterface().getPowerConsumption(node.getPowerInterface().getPowerState()); 
     25                        for(Device dev: node.getResourceCharacteristic().getDevices()){ 
     26                                powerConsumption = powerConsumption + dev.getPowerInterface().getRecentPowerUsage().getValue(); 
     27                        } 
    2428                } catch (NoSuchFieldException e) { 
    2529                } 

  • DCWoRMS/branches/coolemall/src/example/energy/ProcessorEnergyEstimationPlugin.java

    r901 r1207  
    22 
    33import schedframe.resources.ResourceStatus; 
    4 import schedframe.resources.computing.ComputingResource; 
    54import schedframe.resources.computing.Processor; 
    65import schedframe.resources.computing.profiles.energy.EnergyEvent; 
    76import schedframe.resources.computing.profiles.energy.power.StandardPowerStateName; 
     7import schedframe.resources.devices.PhysicalResource; 
    88import schedframe.scheduling.manager.tasks.JobRegistry; 
    99 
    … …  
    1111 
    1212        public double estimatePowerConsumption(EnergyEvent event, JobRegistry jobRegistry, 
    13                         ComputingResource resource) { 
     13                        PhysicalResource resource) { 
    1414                double powerConsumption; 
     15 
    1516                Processor cpu = (Processor)resource; 
    1617                if(resource.getPowerInterface().getPowerState().equals(StandardPowerStateName.OFF)) 

  • DCWoRMS/branches/coolemall/src/example/energy/coolemall/CB1EnergyEstimationPlugin.java

    r913 r1207  
    11package example.energy.coolemall; 
    22 
    3 import schedframe.Parameter; 
    4 import schedframe.resources.computing.ComputingResource; 
     3import schedframe.resources.computing.coolemall.ComputeBox1; 
     4import schedframe.resources.computing.coolemall.NodeGroup; 
    55import schedframe.resources.computing.profiles.energy.EnergyEvent; 
    6 import schedframe.resources.computing.recs.ComputeBox1; 
    7 import schedframe.resources.computing.recs.NodeGroup; 
     6import schedframe.resources.devices.PhysicalResource; 
    87import schedframe.scheduling.manager.tasks.JobRegistry; 
    98import example.energy.BaseEnergyEstimationPlugin; 
    … …  
    1211 
    1312        public double estimatePowerConsumption(EnergyEvent event, JobRegistry jobRegistry, 
    14                         ComputingResource resource) { 
     13                        PhysicalResource resource) { 
    1514                double powerConsumption = 0; 
    1615                ComputeBox1 computeBox1 = (ComputeBox1)resource; 
    … …  
    2221                        } 
    2322                } 
    24  
    25                 try { 
    26                         powerConsumption = powerConsumption + computeBox1.getPowerInterface().getPowerConsumption(computeBox1.getPowerInterface().getPowerState()); 
    27                 } catch (NoSuchFieldException e) { 
    28                         Parameter param = computeBox1.getResourceCharacteristic().getParameters().get("maxPower"); 
    29                         if(param != null) 
    30                                 powerConsumption = powerConsumption + Double.valueOf(param.get(0).getContent()); 
    31                 } 
    32  
    33                  
     23                powerConsumption = (powerConsumption + CoolEmAllTestbedMeasurements.OTHER_DEVICES_POWER_CONSUMPTION)/CoolEmAllTestbedMeasurements.POWER_SUPPLY_EFFICIENCY; 
    3424                return powerConsumption; 
    3525        } 

  • DCWoRMS/branches/coolemall/src/example/energy/coolemall/NodeEnergyEstimationPlugin.java

    r1146 r1207  
    11package example.energy.coolemall; 
    22 
    3 import schedframe.Parameter; 
    4 import schedframe.events.scheduling.EventReason; 
    5 import schedframe.resources.computing.ComputingResource; 
    63import schedframe.resources.computing.Processor; 
     4import schedframe.resources.computing.coolemall.Node; 
    75import schedframe.resources.computing.profiles.energy.EnergyEvent; 
    8 import schedframe.resources.computing.recs.Node; 
     6import schedframe.resources.computing.profiles.energy.power.StandardPowerStateName; 
     7import schedframe.resources.devices.Device; 
     8import schedframe.resources.devices.PhysicalResource; 
    99import schedframe.scheduling.manager.tasks.JobRegistry; 
     10import testbed_hpc.Node_Fan_Mapping; 
    1011import example.energy.BaseEnergyEstimationPlugin; 
    1112 
    1213public class NodeEnergyEstimationPlugin extends BaseEnergyEstimationPlugin { 
    1314 
    14         private static int OUT_START_ID = 0; 
    15         private static int OUT_END_ID = 8; 
     15        //private static int OUT_START_ID = 0; 
     16        //private static int OUT_END_ID = 8; 
    1617         
    1718        public double estimatePowerConsumption(EnergyEvent event, JobRegistry jobRegistry, 
    18                         ComputingResource resource) { 
     19                        PhysicalResource resource) { 
    1920                double powerConsumption = 0; 
    2021                Node node = (Node) resource; 
    … …  
    2627                        } 
    2728                } 
    28                 try { 
    29                         powerConsumption = powerConsumption + node.getPowerInterface().getPowerConsumption(node.getPowerInterface().getPowerState()); 
    30                 } catch (NoSuchFieldException e) { 
    31                         Parameter param = node.getResourceCharacteristic().getParameters().get("maxPower"); 
    32                         if(param != null) 
    33                                 powerConsumption = powerConsumption + Double.valueOf(param.get(0).getContent()); 
    34                 } 
     29                if(node.getPowerInterface().getPowerState().equals(StandardPowerStateName.ON)){ 
     30                        //powerConsumption = powerConsumption + CoolEmAllTestbedMeasurements.SINGLE_FAN_ON_POWER_CONSUMPTION; 
     31                        for(Device device: node.getParent().getResourceCharacteristic().getDevices()){ 
     32                                if(device.getFullName().equals(Node_Fan_Mapping.getNode_fan().get(node.getFullName()))){ 
     33                                        if(device.getPowerInterface().getRecentPowerUsage().getValue() == -1){ 
     34                                                powerConsumption = powerConsumption + CoolEmAllTestbedMeasurements.SINGLE_FAN_ON_POWER_CONSUMPTION; 
     35                                        }else 
     36                                                powerConsumption = powerConsumption + device.getPowerInterface().getRecentPowerUsage().getValue(); 
     37                                        break; 
     38                                } 
     39                        } 
     40                }  
     41 
    3542 
    3643                return powerConsumption; 
    3744        } 
    3845 
    39         public double estimateAirThroughput(EnergyEvent event, JobRegistry jobRegistry, ComputingResource resource) { 
     46        /*public double estimateAirThroughput(EnergyEvent event, JobRegistry jobRegistry, PhysicalResource resource) { 
    4047 
    4148                double airThroughput = 0; 
    … …  
    4451                                return airThroughput; 
    4552                                //airThroughput = resource.getAirThroughputInterface().getAirFlow(StandardAirThroughputStateName.FAN_OFF); 
    46                         else 
     53                        else { 
    4754                                airThroughput = resource.getAirThroughputInterface().getAirFlow(resource.getAirThroughputInterface().getAirThroughputState()); 
     55                                //airThroughput = computingResource.getResourceCharacteristic().getDevices().get(0).getAirThroughputInterface().getAirFlow(resource.getAirThroughputInterface().getAirThroughputState()); 
     56                                //airThroughput = 0.28; 
     57                        } 
    4858                } catch (NoSuchFieldException e) { 
    4959                        // TODO Auto-generated catch block 
    … …  
    5161                } 
    5262                 
    53                 Integer resId = Integer.parseInt(resource.getName().split("_")[1]); 
     63                //Integer resId = Integer.parseInt(resource.getName().split("_")[1]); 
     64                //ComputingResource computingResource = (ComputingResource) resource; 
    5465                //we estimate the air flow related to the outlets (nodes placed in the outlet row of RECS) 
    55                 if(resId >= OUT_START_ID  && resId <= OUT_END_ID){ 
    56                         for(ComputingResource compResource: resource.getParent().getChildren()){ 
    57                                 Integer id = Integer.parseInt(compResource.getName().split("_")[1]); 
    58                                 //we take into account the inlet air flow (nodes placed "behind" the given node) 
    59                                 if(id - resId == 9 || id - resId == -9){ 
    60                                         try { 
    61                                                 airThroughput = airThroughput + compResource.getAirThroughputInterface().getAirFlow(compResource.getAirThroughputInterface().getAirThroughputState())/2; 
    62                                         } catch (NoSuchFieldException e) { 
    63                  
    64                                         } 
    65                                 } 
    66                         } 
    67                 } 
     66                //if(resId >= OUT_START_ID  && resId <= OUT_END_ID){ 
     67                //      for(ComputingResource compResource: computingResource.getParent().getChildren()){ 
     68                //              Integer id = Integer.parseInt(compResource.getName().split("_")[1]); 
     69                //              //we take into account the inlet air flow (nodes placed "behind" the given node) 
     70                //              if(id - resId == 9 || id - resId == -9){ 
     71                //                      try { 
     72                //                              airThroughput = airThroughput + compResource.getAirThroughputInterface().getAirFlow(compResource.getAirThroughputInterface().getAirThroughputState())/2; 
     73                //                      } catch (NoSuchFieldException e) { 
     74                // 
     75                //                      } 
     76                //              } 
     77                //      } 
     78                //} 
    6879 
    6980                return airThroughput; 
    70         } 
     81        }*/ 
    7182 
    72         public double estimateTemperature(EnergyEvent event, JobRegistry jobRegistry, ComputingResource resource) { 
     83        /*public double estimateTemperature(EnergyEvent event, JobRegistry jobRegistry, PhysicalResource resource) { 
    7384                double tout = 0; 
    7485                double tin = 21.3; 
    … …  
    8394                Integer resId = Integer.parseInt(resource.getName().split("_")[1]); 
    8495                 
     96                ComputingResource computingResource = (ComputingResource) resource; 
     97                 
    8598                //we estimate outlet temperature (related to the temperature of the nodes placed in outlet row) 
    86                 for(ComputingResource compResource: resource.getParent().getChildren()){ 
     99                for(ComputingResource compResource: computingResource.getParent().getChildren()){ 
    87100                        Integer id = Integer.parseInt(compResource.getName().split("_")[1]); 
    88101                        //we take into account the power of nodes placed "behind" the given nodes 
    … …  
    98111                tout = tin + delta1 * (power1/(Q * C * ro)) +  delta2 * (power2/(Q * C * ro));; 
    99112                return tout; 
    100         } 
     113        }*/ 
    101114         
    102115} 

  • DCWoRMS/branches/coolemall/src/example/energy/coolemall/NodeGroupEnergyEstimationPlugin.java

    r913 r1207  
    11package example.energy.coolemall; 
    22 
    3 import schedframe.Parameter; 
    4 import schedframe.resources.computing.ComputingResource; 
     3import schedframe.resources.computing.coolemall.Node; 
     4import schedframe.resources.computing.coolemall.NodeGroup; 
    55import schedframe.resources.computing.profiles.energy.EnergyEvent; 
    6 import schedframe.resources.computing.recs.Node; 
    7 import schedframe.resources.computing.recs.NodeGroup; 
     6import schedframe.resources.devices.PhysicalResource; 
    87import schedframe.scheduling.manager.tasks.JobRegistry; 
    98import example.energy.BaseEnergyEstimationPlugin; 
    … …  
    1211 
    1312        public double estimatePowerConsumption(EnergyEvent event, JobRegistry jobRegistry, 
    14                         ComputingResource resource) { 
     13                        PhysicalResource resource) { 
     14                 
    1515                double powerConsumption = 0; 
    1616                NodeGroup nodeGroup = (NodeGroup)resource; 
    17                 for(Node cn: nodeGroup.getNodes()){ 
     17                for(Node node: nodeGroup.getNodes()){ 
    1818                        try{ 
    19                                 powerConsumption = powerConsumption + cn.getPowerInterface().getRecentPowerUsage().getValue(); 
     19                                powerConsumption = powerConsumption + node.getPowerInterface().getRecentPowerUsage().getValue(); 
    2020                        } catch (Exception e){ 
    21                                  
    2221                        } 
    23                 } 
    24                 try { 
    25                         powerConsumption = powerConsumption + nodeGroup.getPowerInterface().getPowerConsumption(nodeGroup.getPowerInterface().getPowerState()); 
    26                 } catch (NoSuchFieldException e) { 
    27                         Parameter param = nodeGroup.getResourceCharacteristic().getParameters().get("maxPower"); 
    28                         if(param != null) 
    29                                 powerConsumption = powerConsumption + Double.valueOf(param.get(0).getContent()); 
    3022                } 
    3123 

  • DCWoRMS/branches/coolemall/src/example/energy/coolemall/ProcessorEnergyEstimationPlugin.java

    r913 r1207  
    11package example.energy.coolemall; 
    22 
    3 import schedframe.Parameter; 
     3import dcworms.schedframe.scheduling.ExecTask; 
    44import schedframe.resources.ResourceStatus; 
    5 import schedframe.resources.computing.ComputingResource; 
     5import schedframe.resources.computing.Core; 
    66import schedframe.resources.computing.Processor; 
    77import schedframe.resources.computing.profiles.energy.EnergyEvent; 
    88import schedframe.resources.computing.profiles.energy.power.StandardPowerStateName; 
     9import schedframe.resources.devices.PhysicalResource; 
    910import schedframe.scheduling.manager.tasks.JobRegistry; 
     11import schedframe.scheduling.manager.tasks.JobRegistryImpl; 
     12import schedframe.scheduling.tasks.phases.PhaseBehaviour; 
    1013import example.energy.BaseEnergyEstimationPlugin; 
    1114 
    … …  
    1316 
    1417        public double estimatePowerConsumption(EnergyEvent event, JobRegistry jobRegistry, 
    15                         ComputingResource resource) { 
    16                 double powerConsumption = 0; 
     18                        PhysicalResource resource) { 
     19                 
     20                /*double powerConsumption = 0; 
    1721                Processor cpu = (Processor)resource; 
    1822                if(resource.getPowerInterface().getPowerState().equals(StandardPowerStateName.OFF)) 
    … …  
    3842                        } 
    3943                } 
     44                return powerConsumption;*/ 
     45                double powerConsumption = 0; 
     46                Processor proc = (Processor)resource; 
     47                if(resource.getPowerInterface().getPowerState().equals(StandardPowerStateName.OFF)) 
     48                        return 0; 
     49                else { 
     50                        double processorLoad; 
     51                        double sumCoresLoad = 0; 
     52                         
     53                        int nrOfThreadsOnCpu = 1; 
     54                         
     55                        if(proc.getResourceCharacteristic().getParameters().get("product") != null){ 
     56                                String productName = proc.getResourceCharacteristic().getParameters().get("product").get(0).getContent(); 
     57                                if(productName.equals("Fusion G - T40N")) 
     58                                        nrOfThreadsOnCpu = CoolEmAllTestbedMeasurements.Fusion_G_T40N_NR_OF_THREADS; 
     59                                else if(productName.equals("Atom - D510")) 
     60                                        nrOfThreadsOnCpu = CoolEmAllTestbedMeasurements.Atom_D510_NR_OF_THREADS; 
     61                                else if(productName.equals("Atom - N2600")) 
     62                                        nrOfThreadsOnCpu = CoolEmAllTestbedMeasurements.Atom_N2600_NR_OF_THREADS; 
     63                                else if(productName.equals("Core i7 - 2715QE")) 
     64                                        nrOfThreadsOnCpu = CoolEmAllTestbedMeasurements.Core_i7_2715QE_NR_OF_THREADS; 
     65                                else if(productName.equals("Core i7 - 3615QE")) 
     66                                        nrOfThreadsOnCpu = CoolEmAllTestbedMeasurements.Core_i7_3615QE_NR_OF_THREADS; 
     67                        } 
     68 
     69                        for(Core core: proc.getCores()){ 
     70                                 
     71                                if(core.getStatus().equals(ResourceStatus.BUSY)){ 
     72                                        JobRegistry jr = new JobRegistryImpl(core.getFullName()); 
     73                                        for(ExecTask task: jr.getRunningTasks()){ 
     74                                                double cpuUsage = 100; 
     75                                                double nrOfThreadsOfApplciation = 1; 
     76                                                for(PhaseBehaviour pb: task.getCurrentResourceConsumption().getBehaviourList()){ 
     77                                                        if(pb.getResouceName().equals("PM_CPU_Usage")){ 
     78                                                                cpuUsage = pb.getUtilization(); 
     79                                                        } 
     80                                                        if(pb.getResouceName().equals("PM_Threads")){ 
     81                                                                nrOfThreadsOfApplciation = pb.getUtilization(); 
     82                                                                break; 
     83                                                        } 
     84                                                } 
     85                                                sumCoresLoad = sumCoresLoad + cpuUsage * (nrOfThreadsOnCpu / nrOfThreadsOfApplciation); 
     86                                        } 
     87                                } 
     88                        } 
     89                        processorLoad = 100 * sumCoresLoad/proc.getCores().size(); 
     90                        double lowestLoadLevel = 100; 
     91                        double highestLoadLevel = 0; 
     92                        if(proc.getPowerInterface().getPState().getLoadPowerUsage().containsKey(new Double(processorLoad))){ 
     93                                powerConsumption = proc.getPowerInterface().getPState().getLoadPowerUsage().get(new Double(processorLoad)); 
     94                                //System.out.println("power from profile: " + powerConsumption); 
     95                        } else { 
     96                                for(Double load: proc.getPowerInterface().getPState().getLoadPowerUsage().keySet()){ 
     97                                        if(lowestLoadLevel > load){ 
     98                                                lowestLoadLevel = load; 
     99                                        } 
     100                                        if(highestLoadLevel < load){ 
     101                                                highestLoadLevel = load; 
     102                                        } 
     103                                } 
     104                                if(processorLoad == 0){ 
     105                                        try{ 
     106                                                powerConsumption = proc.getPowerInterface().getSupportedPowerStates().get(0).getPowerUsage(); 
     107                                                //System.out.println("load = 0; power = idle power usage: " + powerConsumption); 
     108                                        } catch (Exception e){ 
     109                                                powerConsumption = 0.7 * proc.getPowerInterface().getPState().getLoadPowerUsage().get(new Double(highestLoadLevel)); 
     110                                                //System.out.println("error load = 0; power = 0.7 max power: " + powerConsumption); 
     111                                        } 
     112                                } else { 
     113                                         
     114                                        double lowerLoadLevel = lowestLoadLevel; 
     115                                        double higherLoadLevel = highestLoadLevel; 
     116                                         
     117                                        try{ 
     118                                         
     119                                                for(Double load: proc.getPowerInterface().getPState().getLoadPowerUsage().keySet()){ 
     120                                                        if(processorLoad > load){ 
     121                                                                lowerLoadLevel = load; 
     122                                                        } 
     123                                                        else if(processorLoad < load){ 
     124                                                                higherLoadLevel = load; 
     125                                                                break; 
     126                                                        } 
     127                                                } 
     128                                                double powerBelow; 
     129                                                double powerAbove; 
     130                                                double a; 
     131                                                double b; 
     132                                                if(lowerLoadLevel != higherLoadLevel) 
     133                                                { 
     134                                                        powerBelow = proc.getPowerInterface().getPState().getLoadPowerUsage().get(lowerLoadLevel); 
     135                                                        powerAbove = proc.getPowerInterface().getPState().getLoadPowerUsage().get(higherLoadLevel); 
     136                                                        a = (powerAbove - powerBelow)/(higherLoadLevel - lowerLoadLevel); 
     137                                                        b = powerAbove - a * higherLoadLevel; 
     138                                                } else { 
     139                                                        powerBelow = proc.getPowerInterface().getPState().getLoadPowerUsage().get(lowestLoadLevel); 
     140                                                        powerAbove = proc.getPowerInterface().getPState().getLoadPowerUsage().get(highestLoadLevel); 
     141                                                        a = (powerAbove - powerBelow)/(highestLoadLevel - lowestLoadLevel); 
     142                                                        b = powerAbove - a * highestLoadLevel; 
     143                                                } 
     144                                                powerConsumption = a * processorLoad + b; 
     145                                                /*System.out.println("a" +lowestLoadLevel + ";" +highestLoadLevel); 
     146                                                System.out.println("b" +lowerLoadLevel + ";" +higherLoadLevel); 
     147                                                System.out.println("c" +powerBelow + ";" +powerAbove); 
     148                                                System.out.println(resource.getFullName() + "load: " + processorLoad + "linear power estimation " + powerConsumption);*/ 
     149         
     150                                        } catch (Exception e){ 
     151                                                powerConsumption = 0.7 * proc.getPowerInterface().getPState().getLoadPowerUsage().get(new Double(highestLoadLevel));     
     152                                                //System.out.println("error; power = 0.7 max power: " + powerConsumption); 
     153                                        } 
     154                                } 
     155                        } 
     156                } 
     157                         
     158 
     159                powerConsumption = powerConsumption - CoolEmAllTestbedMeasurements.SINGLE_FAN_ON_POWER_CONSUMPTION; 
     160                //System.out.println("estiamted power consumption: " + powerConsumption); 
    40161                return powerConsumption; 
    41162        } 
Note: See TracChangeset for help on using the changeset viewer.