Changeset 1415 for DCWoRMS/branches


Ignore:
Timestamp:
07/15/14 16:26:31 (11 years ago)
Author:
wojtekp
Message:
 
Location:
DCWoRMS/branches/coolemall/src
Files:
5 added
4 deleted
67 edited
6 moved

Legend:

Unmodified
Added
Removed

  • DCWoRMS/branches/coolemall/src/dcworms/schedframe/scheduling/Executable.java

    r1396 r1415  
    3030import schedframe.scheduling.tasks.AbstractProcessesGroup; 
    3131import schedframe.scheduling.tasks.Task; 
    32 import schedframe.scheduling.tasks.phases.ResourceConsumption; 
     32import schedframe.scheduling.tasks.phases.ExecutionPhase; 
    3333import schedframe.scheduling.tasks.phases.ExecutionProfile; 
    3434import schedframe.scheduling.tasks.requirements.ResourceParameterName; 
    … …  
    4848         
    4949        protected String reservationId; 
    50         protected double completionPercentage; 
     50        protected double completionPercentageTotal; 
    5151         
    5252        protected int estimatedDuration; 
    … …  
    6464        protected ExecutionProfile execProfile; 
    6565         
    66         protected LinkedList<ExecutionHistoryItem> execHistory;; 
     66        protected LinkedList<ExecutionHistoryItem> execHistory; 
    6767        protected LinkedList<ResourceItem> allocatedResources; 
    6868         
    … …  
    187187                 
    188188                if (newStatus == DCWormsTags.SUCCESS || newStatus == DCWormsTags.CANCELED) { 
    189             finishTime = DateTimeUtilsExt.currentTimeMillis() / 1000; 
     189            finishTime = currentTime; 
    190190        } 
    191191                 
    … …  
    196196        if ((prevStatus == DCWormsTags.INEXEC) && (status == DCWormsTags.CANCELED || status == DCWormsTags.PAUSED || 
    197197                status == DCWormsTags.SUCCESS)){ 
    198                 totalCompletionTime += (currentTime -  execStartTime); 
    199                 execStartTime = execStartTimeFirst; 
     198            totalCompletionTime += (currentTime -  execStartTime); 
     199            execStartTime = execStartTimeFirst; 
    200200        } 
    201201 
    … …  
    218218        if(status == DCWormsTags.NEW_EXEC_PHASE && prevStatus == DCWormsTags.INEXEC){ 
    219219                status = DCWormsTags.INEXEC; 
    220                 completionPercentage = 0; 
     220                execProfile.setCompletionPercentage(0.0); 
    221221                execProfile.setCurrentPhase(execProfile.getCurrentPhase() + 1); 
    222222        } 
    … …  
    255255        } 
    256256         
    257         public double getCompletionPercentage() { 
    258                 return completionPercentage; 
    259         } 
    260  
    261         public void setCompletionPercentage(double completionPercentage) { 
    262                 this.completionPercentage = completionPercentage; 
     257        public double getTotalCompletionPercentage() { 
     258                return completionPercentageTotal; 
     259        } 
     260 
     261        public void setTotalCompletionPercentage(double completionPercentage) { 
     262                this.completionPercentageTotal = completionPercentage; 
    263263        } 
    264264 
    … …  
    370370        } 
    371371 
    372         public ResourceConsumption getCurrentResourceConsumption(){ 
    373                 return execProfile.getCurrentResourceConsumption(); 
    374         } 
    375          
    376372        public String getApplicationName(){ 
    377373                return task.getApplicationName(); 
    … …  
    379375         
    380376        private void preparePhases(String resourceType) { 
    381                 LinkedList<ResourceConsumption> resourceConsumptionList = new LinkedList<ResourceConsumption>(); 
     377                LinkedList<ExecutionPhase> resourceConsumptionList = new LinkedList<ExecutionPhase>(); 
    382378                 
    383379                long usefulWork = -1; 
    … …  
    385381                if(task.getDescription().getExecution() == null || task.getDescription().getExecution().getResourceConsumptionProfile() == null 
    386382                                || task.getDescription().getExecution().getResourceConsumptionProfile().length == 0 ){ 
    387                         ResourceConsumption resConsumption = null; 
     383                        ExecutionPhase resConsumption = null; 
    388384                        try { 
    389                                 resConsumption = new ResourceConsumption(getLength(), task.getComputingResourceRequirements()); 
     385                                resConsumption = new ExecutionPhase(getLength(), task.getComputingResourceRequirements()); 
    390386                        } catch (NoSuchFieldException e) { 
    391387                                // TODO Auto-generated catch block 
    … …  
    399395                                        if(resConsumptioProfile.getType() != null && resConsumptioProfile.getType().equals(resourceType)){ 
    400396                                                for(ResourceConsumptionType resConsumption: resConsumptioProfile.getResourceConsumption()){ 
    401                                                         ResourceConsumption resourceConsumption = new ResourceConsumption(resConsumption); 
     397                                                        ExecutionPhase resourceConsumption = new ExecutionPhase(resConsumption); 
    402398                                                        resourceConsumptionList.add(resourceConsumption); 
    403399                                                } 
    … …  
    415411                        if(!found){ 
    416412                                for(ResourceConsumptionType resConsumption: task.getDescription().getExecution().getResourceConsumptionProfile()[0].getResourceConsumption()){ 
    417                                         ResourceConsumption resourceConsumption = new ResourceConsumption(resConsumption); 
     413                                        ExecutionPhase resourceConsumption = new ExecutionPhase(resConsumption); 
    418414                                        resourceConsumptionList.add(resourceConsumption); 
    419415                                } 

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

    r1396 r1415  
    33import schedframe.Parameters; 
    44import schedframe.PluginConfiguration; 
    5 import schedframe.resources.computing.profiles.energy.EnergyEvent; 
     5import schedframe.resources.computing.profiles.energy.ResourceEvent; 
    66import schedframe.resources.computing.profiles.energy.power.plugin.EnergyEstimationPlugin; 
     7import schedframe.resources.computing.profiles.energy.power.plugin.EnergyPluginConfiguration; 
    78import schedframe.resources.devices.PhysicalResource; 
    89import schedframe.scheduling.manager.tasks.JobRegistry; 
     10import schemas.StringValueWithUnit; 
    911 
    1012public abstract class BaseEnergyEstimationPlugin implements EnergyEstimationPlugin { 
    1113 
     14         EnergyPluginConfiguration plugConf; 
     15          
    1216        @Override 
    1317        public PluginConfiguration getConfiguration() { 
    14                 // TODO Auto-generated method stub 
    15                 return null; 
     18                return plugConf; 
    1619        } 
    1720         
    1821        @Override 
    19         public double estimateAirflow(EnergyEvent event, JobRegistry jobRegistry, PhysicalResource resource) { 
     22        public double estimateAirflow(ResourceEvent event, JobRegistry jobRegistry, PhysicalResource resource) { 
    2023                throw new RuntimeException("Not implemented."); 
    2124        } 
    2225 
    2326        @Override 
    24         public double estimateTemperature(EnergyEvent event, JobRegistry jobRegistry, PhysicalResource  resource) { 
     27        public double estimateTemperature(ResourceEvent event, JobRegistry jobRegistry, PhysicalResource  resource) { 
    2528                throw new RuntimeException("Not implemented."); 
    2629        } 
    2730         
    2831        public void init(Parameters parameters) { 
    29  
     32                plugConf = new EnergyPluginConfiguration(); 
     33                try{ 
     34                        StringValueWithUnit powerCapLevel = parameters.get("powerCapLevel").get(0); 
     35                        plugConf.setPowerCapLevel(Double.valueOf(powerCapLevel.getContent()).doubleValue()); 
     36                } catch(Exception e){ 
     37                        plugConf.setPowerCapLevel(-1); 
     38                } 
     39                try{ 
     40                        StringValueWithUnit powerFloorLevel = parameters.get("powerFloorLevel").get(0); 
     41                        plugConf.setPowerFloorLevel(Double.valueOf(powerFloorLevel.getContent()).doubleValue()); 
     42                } catch(Exception e){ 
     43                        plugConf.setPowerFloorLevel(-1); 
     44                } 
    3045        } 
    3146 

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

    r1258 r1415  
    33import schedframe.resources.computing.Node; 
    44import schedframe.resources.computing.DataCenter; 
    5 import schedframe.resources.computing.profiles.energy.EnergyEvent; 
     5import schedframe.resources.computing.profiles.energy.ResourceEvent; 
    66import schedframe.resources.computing.profiles.energy.power.PowerUsage; 
    77import schedframe.resources.devices.PhysicalResource; 
    … …  
    1111 
    1212        @Override 
    13         public double estimatePowerConsumption(EnergyEvent event, JobRegistry jobRegistry, 
     13        public double estimatePowerConsumption(ResourceEvent event, JobRegistry jobRegistry, 
    1414                        PhysicalResource resource) { 
    1515                double power = 0; 

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

    r1207 r1415  
    22 
    33import schedframe.resources.computing.ComputingResource; 
    4 import schedframe.resources.computing.profiles.energy.EnergyEvent; 
     4import schedframe.resources.computing.profiles.energy.ResourceEvent; 
    55import schedframe.resources.devices.PhysicalResource; 
    66import schedframe.scheduling.manager.tasks.JobRegistry; 
    … …  
    1010 
    1111 
    12         public double estimatePowerConsumption(EnergyEvent event, JobRegistry jobRegistry, PhysicalResource resource) { 
     12        public double estimatePowerConsumption(ResourceEvent event, JobRegistry jobRegistry, PhysicalResource resource) { 
    1313                double powerConsumption = 0; 
    1414                try { 

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

    r1247 r1415  
    33import schedframe.resources.computing.Node; 
    44import schedframe.resources.computing.Processor; 
    5 import schedframe.resources.computing.profiles.energy.EnergyEvent; 
     5import schedframe.resources.computing.profiles.energy.ResourceEvent; 
    66import schedframe.resources.devices.Device; 
    77import schedframe.resources.devices.PhysicalResource; 
    … …  
    1010public class NodeEnergyEstimationPlugin extends BaseEnergyEstimationPlugin { 
    1111 
    12         public double estimatePowerConsumption(EnergyEvent event, JobRegistry jobRegistry, 
     12        public double estimatePowerConsumption(ResourceEvent event, JobRegistry jobRegistry, 
    1313                        PhysicalResource resource) { 
    1414                double powerConsumption = 0; 

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

    r1207 r1415  
    33import schedframe.resources.ResourceStatus; 
    44import schedframe.resources.computing.Processor; 
    5 import schedframe.resources.computing.profiles.energy.EnergyEvent; 
     5import schedframe.resources.computing.profiles.energy.ResourceEvent; 
    66import schedframe.resources.computing.profiles.energy.power.StandardPowerStateName; 
    77import schedframe.resources.devices.PhysicalResource; 
    … …  
    1010public class ProcessorEnergyEstimationPlugin extends BaseEnergyEstimationPlugin  { 
    1111 
    12         public double estimatePowerConsumption(EnergyEvent event, JobRegistry jobRegistry, 
     12        public double estimatePowerConsumption(ResourceEvent event, JobRegistry jobRegistry, 
    1313                        PhysicalResource resource) { 
    1414                double powerConsumption; 
    … …  
    4242                         
    4343                } 
     44                if(cpu.getLoadInterface().getRecentUtilization().getValue() != 0.0){ 
     45                        powerConsumption = powerConsumption * cpu.getLoadInterface().getRecentUtilization().getValue()/100;                      
     46                } 
    4447                return powerConsumption; 
    4548        } 

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

    r1396 r1415  
    1010import schedframe.resources.computing.coolemall.ComputeBox1; 
    1111import schedframe.resources.computing.coolemall.NodeGroup; 
    12 import schedframe.resources.computing.profiles.energy.EnergyEvent; 
     12import schedframe.resources.computing.profiles.energy.ResourceEvent; 
    1313import schedframe.resources.computing.profiles.energy.airthroughput.CustomAirflowStateName; 
    1414import schedframe.resources.computing.profiles.energy.power.PState; 
    … …  
    2626        double powerUpgradeLevel = -1; 
    2727         
    28         public double estimatePowerConsumption(EnergyEvent event, JobRegistry jobRegistry, 
     28        public double estimatePowerConsumption(ResourceEvent event, JobRegistry jobRegistry, 
    2929                        PhysicalResource resource) { 
    3030                 

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

    r1396 r1415  
    88import schedframe.resources.computing.coolemall.ComputeBox1; 
    99import schedframe.resources.computing.coolemall.NodeGroup; 
    10 import schedframe.resources.computing.profiles.energy.EnergyEvent; 
     10import schedframe.resources.computing.profiles.energy.ResourceEvent; 
    1111import schedframe.resources.computing.profiles.energy.power.StandardPowerStateName; 
    1212import schedframe.resources.devices.Device; 
    … …  
    1919public class CB2EnergyEstimationPlugin extends BaseEnergyEstimationPlugin{ 
    2020 
    21         public double estimatePowerConsumption(EnergyEvent event, JobRegistry jobRegistry, 
     21        public double estimatePowerConsumption(ResourceEvent event, JobRegistry jobRegistry, 
    2222                        PhysicalResource resource) { 
    2323                 

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

    r1396 r1415  
    77import schedframe.resources.computing.coolemall.ComputeBox1; 
    88import schedframe.resources.computing.coolemall.NodeGroup; 
    9 import schedframe.resources.computing.profiles.energy.EnergyEvent; 
     9import schedframe.resources.computing.profiles.energy.ResourceEvent; 
    1010import schedframe.resources.computing.profiles.energy.power.StandardPowerStateName; 
    1111import schedframe.resources.devices.Device; 
    … …  
    1818public class CoolingDeviceEnergyEstimationPlugin extends BaseEnergyEstimationPlugin { 
    1919 
    20         public double estimateAirflow(EnergyEvent event, JobRegistry jobRegistry, PhysicalResource resource) { 
     20        public double estimateAirflow(ResourceEvent event, JobRegistry jobRegistry, PhysicalResource resource) { 
    2121                double airflow = 0; 
    2222                return airflow; 
    2323        } 
    2424 
    25         public double estimatePowerConsumption(EnergyEvent event, JobRegistry jobRegistry, 
     25        public double estimatePowerConsumption(ResourceEvent event, JobRegistry jobRegistry, 
    2626                        PhysicalResource resource) { 
    2727                 

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

    r1396 r1415  
    11package example.energy.coolemall; 
    22 
    3 import schedframe.events.scheduling.EventReason; 
     3import schedframe.events.EventReason; 
    44import schedframe.resources.computing.ComputingResource; 
    55import schedframe.resources.computing.Node; 
    6 import schedframe.resources.computing.profiles.energy.EnergyEvent; 
     6import schedframe.resources.computing.profiles.energy.ResourceEvent; 
    77import schedframe.resources.computing.profiles.energy.power.StandardPowerStateName; 
    88import schedframe.resources.devices.Device; 
    … …  
    1414public class FanEnergyEstimationPlugin extends BaseEnergyEstimationPlugin { 
    1515 
    16         public double estimatePowerConsumption(EnergyEvent event, JobRegistry jobRegistry, 
     16        public double estimatePowerConsumption(ResourceEvent event, JobRegistry jobRegistry, 
    1717                        PhysicalResource resource) { 
    1818                 
    … …  
    3535        } 
    3636         
    37         public double estimateAirflow(EnergyEvent event, JobRegistry jobRegistry, PhysicalResource resource) { 
     37        public double estimateAirflow(ResourceEvent event, JobRegistry jobRegistry, PhysicalResource resource) { 
    3838                 
    3939                double airflow = 0; 

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

    r1396 r1415  
    55import schedframe.resources.computing.coolemall.ComputeBox1; 
    66import schedframe.resources.computing.coolemall.NodeGroup; 
    7 import schedframe.resources.computing.profiles.energy.EnergyEvent; 
     7import schedframe.resources.computing.profiles.energy.ResourceEvent; 
    88import schedframe.resources.devices.Device; 
    99import schedframe.resources.devices.Fan; 
    … …  
    1515public class FlowPumpInletEnergyEstimationPlugin extends BaseEnergyEstimationPlugin { 
    1616 
    17         public double estimatePowerConsumption(EnergyEvent event, JobRegistry jobRegistry, 
     17        public double estimatePowerConsumption(ResourceEvent event, JobRegistry jobRegistry, 
    1818                        PhysicalResource resource) { 
    1919                 
    … …  
    8686        } 
    8787         
    88         public double estimateAirflow(EnergyEvent event, JobRegistry jobRegistry, PhysicalResource resource) { 
     88        public double estimateAirflow(ResourceEvent event, JobRegistry jobRegistry, PhysicalResource resource) { 
    8989                double airflow = 0; 
    9090                double Vair_total; 

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

    r1396 r1415  
    55import schedframe.resources.computing.coolemall.ComputeBox1; 
    66import schedframe.resources.computing.coolemall.NodeGroup; 
    7 import schedframe.resources.computing.profiles.energy.EnergyEvent; 
     7import schedframe.resources.computing.profiles.energy.ResourceEvent; 
    88import schedframe.resources.devices.Device; 
    99import schedframe.resources.devices.Fan; 
    … …  
    1515public class FlowPumpOutletEnergyEstimationPlugin extends BaseEnergyEstimationPlugin { 
    1616 
    17         public double estimatePowerConsumption(EnergyEvent event, JobRegistry jobRegistry, 
     17        public double estimatePowerConsumption(ResourceEvent event, JobRegistry jobRegistry, 
    1818                        PhysicalResource resource) { 
    1919                 
    … …  
    2323        } 
    2424         
    25         public double estimateAirflow(EnergyEvent event, JobRegistry jobRegistry, PhysicalResource resource) { 
     25        public double estimateAirflow(ResourceEvent event, JobRegistry jobRegistry, PhysicalResource resource) { 
    2626                double airflow = 0; 
    2727                double Vair_total; 

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

    r1247 r1415  
    33import schedframe.resources.computing.Node; 
    44import schedframe.resources.computing.Processor; 
    5 import schedframe.resources.computing.profiles.energy.EnergyEvent; 
     5import schedframe.resources.computing.profiles.energy.ResourceEvent; 
    66import schedframe.resources.devices.Device; 
    77import schedframe.resources.devices.PhysicalResource; 
    … …  
    1111public class HeatsinkEnergyEstimationPlugin extends BaseEnergyEstimationPlugin  { 
    1212 
    13         public double estimatePowerConsumption(EnergyEvent event, JobRegistry jobRegistry, 
     13        public double estimatePowerConsumption(ResourceEvent event, JobRegistry jobRegistry, 
    1414                        PhysicalResource resource) { 
    1515                 

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

    r1396 r1415  
    55import schedframe.resources.computing.Node; 
    66import schedframe.resources.computing.Processor; 
    7 import schedframe.resources.computing.profiles.energy.EnergyEvent; 
     7import schedframe.resources.computing.profiles.energy.ResourceEvent; 
    88import schedframe.resources.computing.profiles.energy.power.StandardPowerStateName; 
    99import schedframe.resources.devices.Device; 
    … …  
    1515public class NodeEnergyEstimationPlugin extends BaseEnergyEstimationPlugin { 
    1616 
    17         public double estimatePowerConsumption(EnergyEvent event, JobRegistry jobRegistry, 
     17        public double estimatePowerConsumption(ResourceEvent event, JobRegistry jobRegistry, 
    1818                        PhysicalResource resource) { 
    1919                double powerConsumption = 0; 

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

    r1247 r1415  
    33import schedframe.resources.computing.Node; 
    44import schedframe.resources.computing.coolemall.NodeGroup; 
    5 import schedframe.resources.computing.profiles.energy.EnergyEvent; 
     5import schedframe.resources.computing.profiles.energy.ResourceEvent; 
    66import schedframe.resources.devices.PhysicalResource; 
    77import schedframe.scheduling.manager.tasks.JobRegistry; 
    … …  
    1010public class NodeGroupEnergyEstimationPlugin extends BaseEnergyEstimationPlugin{ 
    1111 
    12         public double estimatePowerConsumption(EnergyEvent event, JobRegistry jobRegistry, 
     12        public double estimatePowerConsumption(ResourceEvent event, JobRegistry jobRegistry, 
    1313                        PhysicalResource resource) { 
    1414                 

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

    r1322 r1415  
    22 
    33import schedframe.resources.computing.Processor; 
    4 import schedframe.resources.computing.profiles.energy.EnergyEvent; 
     4import schedframe.resources.computing.profiles.energy.ResourceEvent; 
    55import schedframe.resources.computing.profiles.energy.power.StandardPowerStateName; 
    66import schedframe.resources.devices.PhysicalResource; 
    … …  
    1010public class ProcessorEnergyEstimationPlugin extends BaseEnergyEstimationPlugin  { 
    1111 
    12         public double estimatePowerConsumption(EnergyEvent event, JobRegistry jobRegistry, 
     12        public double estimatePowerConsumption(ResourceEvent event, JobRegistry jobRegistry, 
    1313                        PhysicalResource resource) { 
    1414                 

  • DCWoRMS/branches/coolemall/src/example/energy/device/FanEnergyEstimationPlugin.java

    r1396 r1415  
    11package example.energy.device; 
    22 
    3 import schedframe.events.scheduling.EventReason; 
    4 import schedframe.resources.computing.profiles.energy.EnergyEvent; 
     3import schedframe.events.EventReason; 
     4import schedframe.resources.computing.profiles.energy.ResourceEvent; 
    55import schedframe.resources.computing.profiles.energy.airthroughput.StandardAirflowStateName; 
    66import schedframe.resources.devices.PhysicalResource; 
    … …  
    1010public class FanEnergyEstimationPlugin extends BaseEnergyEstimationPlugin { 
    1111 
    12         public double estimatePowerConsumption(EnergyEvent event, JobRegistry jobRegistry, 
     12        public double estimatePowerConsumption(ResourceEvent event, JobRegistry jobRegistry, 
    1313                        PhysicalResource resource) { 
    1414                double powerConsumption = 0; 
    … …  
    2424        } 
    2525 
    26         public double estimateAirflow(EnergyEvent event, JobRegistry jobRegistry, PhysicalResource resource) { 
     26        public double estimateAirflow(ResourceEvent event, JobRegistry jobRegistry, PhysicalResource resource) { 
    2727                double airflow= 0; 
    2828                try { 

  • DCWoRMS/branches/coolemall/src/example/load/DefaultLoadEstimationPlugin.java

    r1396 r1415  
    22 
    33import schedframe.resources.computing.ComputingResource; 
    4 import schedframe.resources.computing.profiles.energy.EnergyEvent; 
     4import schedframe.resources.computing.profiles.energy.ResourceEvent; 
    55import schedframe.resources.devices.PhysicalResource; 
    66import schedframe.scheduling.manager.tasks.JobRegistry; 
    … …  
    1010public class DefaultLoadEstimationPlugin extends BaseLoadEstimationPlugin{ 
    1111 
    12         public double estimateUtlization(EnergyEvent event, JobRegistry jobRegistry, PhysicalResource resource) { 
     12        public double estimateUtlization(ResourceEvent event, JobRegistry jobRegistry, PhysicalResource resource) { 
    1313 
    1414                ComputingResource computingResource = (ComputingResource) resource; 

  • DCWoRMS/branches/coolemall/src/example/load/ProcessorLoadEstimationPlugin.java

    r1396 r1415  
    22 
    33import schedframe.resources.computing.Processor; 
    4 import schedframe.resources.computing.profiles.energy.EnergyEvent; 
     4import schedframe.resources.computing.profiles.energy.ResourceEvent; 
    55import schedframe.resources.devices.PhysicalResource; 
    66import schedframe.scheduling.manager.tasks.JobRegistry; 
    77import schedframe.scheduling.manager.tasks.JobRegistryImpl; 
    8 import schedframe.scheduling.tasks.phases.PhaseBehaviour; 
     8import schedframe.scheduling.tasks.phases.PhaseSystemLoad; 
    99import dcworms.schedframe.scheduling.ExecTask; 
    1010 
    1111public class ProcessorLoadEstimationPlugin extends BaseLoadEstimationPlugin{ 
    1212 
    13         public double estimateUtlization(EnergyEvent event, JobRegistry jobRegistry, PhysicalResource resource) { 
     13        public double estimateUtlization(ResourceEvent event, JobRegistry jobRegistry, PhysicalResource resource) { 
    1414                Processor proc = (Processor) resource; 
    1515                double sumCoresLoad = 0; 
    … …  
    2626                        double cpuUsage = 1 / nrOfThreadsOnCpu; 
    2727 
    28                         for(PhaseBehaviour pb: task.getExecutionProfile().getCurrentResourceConsumption().getBehaviourList()){ 
     28                        for(PhaseSystemLoad pb: task.getExecutionProfile().getCurrentResourceConsumption().getSystemLoad()){ 
    2929                                if(pb.getResouceName().equals("PM_CPU_Usage")){ 
    3030                                        cpuUsage = pb.getUtilization(); 

  • DCWoRMS/branches/coolemall/src/example/localplugin/BaseLocalSchedulingPlugin.java

    r1396 r1415  
    66import schedframe.Parameters; 
    77import schedframe.PluginConfiguration; 
    8 import schedframe.events.scheduling.SchedulingEvent; 
    98import schedframe.events.scheduling.SchedulingEventType; 
    10 import schedframe.events.scheduling.SchedulingResponseType; 
    119import schedframe.resources.units.ResourceUnit; 
    1210import schedframe.resources.units.ResourceUnitName; 
    1311import schedframe.scheduling.TaskList; 
    1412import schedframe.scheduling.manager.resources.ResourceManager; 
    15 import schedframe.scheduling.manager.tasks.JobRegistry; 
    1613import schedframe.scheduling.plan.impl.Allocation; 
    1714import schedframe.scheduling.plan.impl.ScheduledTask; 
    … …  
    3128        public PluginConfiguration getConfiguration() { 
    3229                return plugConf; 
    33         } 
    34          
    35         public SchedulingResponseType handleResourceAllocationViolation(SchedulingEvent event, 
    36                         TaskQueueList queues,  
    37                         JobRegistry jobRegistry,  
    38                                         ResourceManager resourceManager, ModuleList modules){ 
    39                 SchedulingResponseType responeEvent = null; 
    40                 switch(event.getType()){ 
    41                         case TASK_REQUESTED_TIME_EXPIRED:  
    42                                 responeEvent = SchedulingResponseType.KILL_TASK; 
    43                                 break; 
    44                 } 
    45                 return responeEvent; 
    4630        } 
    4731         

  • DCWoRMS/branches/coolemall/src/example/localplugin/Cluster_FCFSBF_ConsolidationHighPerf_NodePowMan_Plugin.java

    r1396 r1415  
    77import java.util.Comparator; 
    88import java.util.HashMap; 
     9import java.util.HashSet; 
    910import java.util.List; 
    1011import java.util.Map; 
     12import java.util.Set; 
    1113 
    1214import schedframe.events.scheduling.SchedulingEvent; 
    13 import schedframe.exceptions.ResourceException; 
    1415import schedframe.resources.ResourceStatus; 
    1516import schedframe.resources.StandardResourceType; 
    … …  
    1718import schedframe.resources.computing.Node; 
    1819import schedframe.resources.computing.Processor; 
    19 import schedframe.resources.computing.profiles.energy.airthroughput.StandardAirflowStateName; 
     20import schedframe.resources.computing.profiles.energy.airthroughput.AirflowState; 
     21import schedframe.resources.computing.profiles.energy.airthroughput.AirflowStateName; 
     22import schedframe.resources.computing.profiles.energy.airthroughput.CustomAirflowStateName; 
    2023import schedframe.resources.computing.profiles.energy.power.PState; 
    2124import schedframe.resources.computing.profiles.energy.power.StandardPowerStateName; 
    2225import schedframe.resources.devices.Device; 
     26import schedframe.resources.devices.Fan; 
    2327import schedframe.resources.units.ProcessingElements; 
    2428import schedframe.resources.units.ResourceUnit; 
    … …  
    5559                        // check all tasks in queue 
    5660 
    57                         List<Node> notSelectedNodes = resourceManager.getNodes(); 
     61                        Set<Node> selectedNodes = new HashSet<Node>(); 
    5862                         
    5963                        for (int i = 0; i < q.size(); i++) { 
    … …  
    6771                                                ProcessingElements pe = (ProcessingElements) choosenResources.get(StandardResourceUnitName.PE); 
    6872                                                Node node = (Node) pe.get(0).getParent(); 
    69                                                 notSelectedNodes.remove(node); 
     73                                                selectedNodes.add(node); 
    7074                                        }  
    7175                                } 
    7276                        } 
    73                         turnOffIdleNodes(notSelectedNodes); 
     77                        List<Node> nodes = resourceManager.getNodes(); 
     78                        nodes.removeAll(selectedNodes); 
     79                        turnOffIdleNodes(nodes); 
     80                        for(Node node: resourceManager.getNodes()){ 
     81                                for(Device device: node.getParent().getResourceCharacteristic().getDevices()){ 
     82                                        if(device.getType().equals(StandardResourceType.Fan)){ 
     83                                                Fan fan = (Fan) device; 
     84                                                adjustFanSpeed(fan, selectedNodes); 
     85                                                break; 
     86                                        } 
     87                                } 
     88                        } 
    7489                        break; 
    7590                } 
    … …  
    8499                Node node; 
    85100                if(availableNodes.size() == 0){ 
    86                         try { 
    87                                 nodes = (List<Node>) resourceManager.getResourcesByTypeWithStatus(StandardResourceType.Node, ResourceStatus.UNAVAILABLE); 
    88                         } catch (ResourceException e) { 
    89                                 // TODO Auto-generated catch block 
    90                                 e.printStackTrace(); 
    91                         } 
     101 
     102                        nodes = (List<Node>) resourceManager.getResourcesByTypeWithStatus(StandardResourceType.Node, ResourceStatus.UNAVAILABLE); 
     103 
    92104                        Collections.sort(nodes, new PerformanceComparator()); 
    93105                        node = turnOnFirstNode(nodes, task); 
    … …  
    112124                        } 
    113125                } 
     126 
    114127                ProcessingElements result = new ProcessingElements(node.getFullName()); 
    115128                result.addAll(choosenResources); 
    … …  
    167180                                        continue; 
    168181                                else { 
    169                                         for(Device device: node.getParent().getResourceCharacteristic().getDevices()){ 
    170                                                 if(device.getType().equals(StandardResourceType.Fan)){ 
    171                                                         device.getAirflowInterface().setAirflowState(StandardAirflowStateName.ON); 
    172                                                         break; 
    173                                                 } 
    174                                         } 
    175182                                        node.getPowerInterface().setPowerState(StandardPowerStateName.ON); 
    176183                                        startedNode = node; 
    … …  
    190197                         
    191198                        if(freeProcessors == node.getProcessors().size()) { 
    192                                 for(Device device: node.getParent().getResourceCharacteristic().getDevices()){ 
    193                                         if(device.getType().equals(StandardResourceType.Fan)){ 
    194                                                 device.getAirflowInterface().setAirflowState(StandardAirflowStateName.OFF); 
    195                                                 break; 
    196                                         } 
    197                                 } 
    198199                                node.getPowerInterface().setPowerState(StandardPowerStateName.OFF); 
    199200                        } 
    200  
    201201                } 
    202202        } 
    … …  
    249249            } 
    250250        } 
     251         
     252        private void adjustFanSpeed(Fan fan, Set<Node> selectedNodes){ 
     253                AirflowStateName newState; 
     254                double totalLoad = 0; 
     255                double loadLevel; 
     256                ComputingResource compRes = fan.getComputingResource(); 
     257                for(ComputingResource n: compRes.getChildren()){ 
     258                        if(fan.getChilledResources().contains(n.getFullName())){ 
     259                                if(selectedNodes.contains(n)){ 
     260                                        totalLoad = totalLoad + 100; 
     261                                } else { 
     262                                        totalLoad = totalLoad + n.getLoadInterface().getRecentUtilization().getValue(); 
     263                                }        
     264                        } 
     265                } 
     266                loadLevel = totalLoad / compRes.getChildren().size(); 
     267                 
     268                double highestLoadLevel = 0; 
     269 
     270                if(fan.getAirflowInterface().supportAirflowState(new CustomAirflowStateName("ON_" + new Double(loadLevel).intValue()))){ 
     271                        newState = new CustomAirflowStateName("ON_" + new Double(loadLevel).intValue()); 
     272                } else { 
     273                        for(AirflowState airflowState: fan.getAirflowInterface().getSupportedAirflowStates()){ 
     274                                Double load; 
     275                                try{ 
     276                                        load = Double.valueOf(airflowState.getName().getLabel().substring(3)); 
     277                                }catch (Exception e){ 
     278                                        continue; 
     279                                } 
     280                                if(highestLoadLevel < load){ 
     281                                        highestLoadLevel = load; 
     282                                } 
     283                        } 
     284                        if(loadLevel == 0){ 
     285                                newState = new CustomAirflowStateName("OFF"); 
     286                        } else { 
     287 
     288                                double higherLoadLevel = highestLoadLevel; 
     289 
     290                                for(AirflowState airflowState: fan.getAirflowInterface().getSupportedAirflowStates()){ 
     291                                        Double load; 
     292                                        try{ 
     293                                                load = Double.valueOf(airflowState.getName().getLabel().substring(3)); 
     294                                        }catch (Exception e){ 
     295                                                continue; 
     296                                        } 
     297                                        if(loadLevel < load){ 
     298                                                higherLoadLevel = load; 
     299                                        } 
     300                                } 
     301                                newState = new CustomAirflowStateName("ON_" + Double.valueOf(higherLoadLevel).intValue()); 
     302                        } 
     303                } 
     304                fan.getAirflowInterface().setAirflowState(newState); 
     305        } 
    251306 
    252307} 

  • DCWoRMS/branches/coolemall/src/example/localplugin/Cluster_FCFSBF_ConsolidationLowPower_NodePowMan_Plugin.java

    r1396 r1415  
    1111 
    1212import schedframe.events.scheduling.SchedulingEvent; 
    13 import schedframe.exceptions.ResourceException; 
    1413import schedframe.resources.ResourceStatus; 
    1514import schedframe.resources.StandardResourceType; 
    … …  
    8382                Node node; 
    8483                if(availableNodes.size() == 0){ 
    85                         try { 
    86                                 nodes = (List<Node>) resourceManager.getResourcesByTypeWithStatus(StandardResourceType.Node, ResourceStatus.UNAVAILABLE); 
    87                         } catch (ResourceException e) { 
    88                                 // TODO Auto-generated catch block 
    89                                 e.printStackTrace(); 
    90                         } 
     84                         
     85                        nodes = (List<Node>) resourceManager.getResourcesByTypeWithStatus(StandardResourceType.Node, ResourceStatus.UNAVAILABLE); 
     86 
    9187                        Collections.sort(nodes, new PowerComparator()); 
    9288                        node = turnOnFirstNode(nodes, task); 

  • DCWoRMS/branches/coolemall/src/example/localplugin/coolemall/computebox1/CB1_FCFS_ConsolidationHighPerf_NodePowMan_SP.java

    r1396 r1415  
    99 
    1010import schedframe.events.scheduling.SchedulingEvent; 
    11 import schedframe.exceptions.ResourceException; 
    1211import schedframe.resources.ResourceStatus; 
    1312import schedframe.resources.StandardResourceType; 
    … …  
    9493                Node node; 
    9594                if(avNodes.size() == 0){ 
    96                         try { 
    97                                 nodes = (List<Node>) resourceManager.getResourcesByTypeWithStatus(StandardResourceType.Node, ResourceStatus.UNAVAILABLE); 
    98                         } catch (ResourceException e) { 
    99                                 // TODO Auto-generated catch block 
    100                                 e.printStackTrace(); 
    101                         } 
     95 
     96                        nodes = (List<Node>) resourceManager.getResourcesByTypeWithStatus(StandardResourceType.Node, ResourceStatus.UNAVAILABLE); 
     97 
    10298                        Collections.sort(nodes, new FavourableNodeComparator()); 
    10399                        node = turnOnFirstNode(nodes, task); 

  • DCWoRMS/branches/coolemall/src/example/localplugin/coolemall/computebox1/CB1_FCFS_ConsolidationLowPower_NodePowMan_SP.java

    r1396 r1415  
    99 
    1010import schedframe.events.scheduling.SchedulingEvent; 
    11 import schedframe.exceptions.ResourceException; 
    1211import schedframe.resources.ResourceStatus; 
    1312import schedframe.resources.StandardResourceType; 
    … …  
    9493                Node node; 
    9594                if(avNodes.size() == 0){ 
    96                         try { 
    97                                 nodes = (List<Node>) resourceManager.getResourcesByTypeWithStatus(StandardResourceType.Node, ResourceStatus.UNAVAILABLE); 
    98                         } catch (ResourceException e) { 
    99                                 // TODO Auto-generated catch block 
    100                                 e.printStackTrace(); 
    101                         } 
     95 
     96                        nodes = (List<Node>) resourceManager.getResourcesByTypeWithStatus(StandardResourceType.Node, ResourceStatus.UNAVAILABLE); 
     97 
    10298                        Collections.sort(nodes, new FavourableNodeComparator()); 
    10399                        node = turnOnFirstNode(nodes, task); 

  • DCWoRMS/branches/coolemall/src/example/localplugin/coolemall/computebox2/CB2_FCFS_ConsolidationHighPerf_NodePowMan_SP.java

    r1396 r1415  
    99 
    1010import schedframe.events.scheduling.SchedulingEvent; 
    11 import schedframe.exceptions.ResourceException; 
    1211import schedframe.resources.ResourceStatus; 
    1312import schedframe.resources.StandardResourceType; 
    … …  
    9594                Node node; 
    9695                if(avNodes.size() == 0){ 
    97                         try { 
    98                                 nodes = (List<Node>) resourceManager.getResourcesByTypeWithStatus(StandardResourceType.Node, ResourceStatus.UNAVAILABLE); 
    99                         } catch (ResourceException e) { 
    100                                 // TODO Auto-generated catch block 
    101                                 e.printStackTrace(); 
    102                         } 
     96                         
     97                        nodes = (List<Node>) resourceManager.getResourcesByTypeWithStatus(StandardResourceType.Node, ResourceStatus.UNAVAILABLE); 
     98 
    10399                        Collections.sort(nodes, new PerformanceComparator()); 
    104100                        node = turnOnFirstNode(nodes, task); 

  • DCWoRMS/branches/coolemall/src/example/localplugin/coolemall/computebox2/CB2_FCFS_ConsolidationLowPower_NodePowMan_SP.java

    r1396 r1415  
    99 
    1010import schedframe.events.scheduling.SchedulingEvent; 
    11 import schedframe.exceptions.ResourceException; 
    1211import schedframe.resources.ResourceStatus; 
    1312import schedframe.resources.StandardResourceType; 
    … …  
    9493                Node node; 
    9594                if(avNodes.size() == 0){ 
    96                         try { 
    97                                 nodes = (List<Node>) resourceManager.getResourcesByTypeWithStatus(StandardResourceType.Node, ResourceStatus.UNAVAILABLE); 
    98                         } catch (ResourceException e) { 
    99                                 // TODO Auto-generated catch block 
    100                                 e.printStackTrace(); 
    101                         } 
     95 
     96                        nodes = (List<Node>) resourceManager.getResourcesByTypeWithStatus(StandardResourceType.Node, ResourceStatus.UNAVAILABLE); 
     97 
    10298                        Collections.sort(nodes, new PowerComparator()); 
    10399                        node = turnOnFirstNode(nodes, task); 

  • DCWoRMS/branches/coolemall/src/example/localplugin/coolemall/computebox2/CB2_FCFS_Random_PowerCapping_SP.java

    r1396 r1415  
    7878                                if (task.getStatus() == DCWormsTags.READY) { 
    7979 
    80                                         try { 
    81                                                 if(resourceManager.getResourcesByTypeWithStatus(StandardResourceType.Core, ResourceStatus.FREE).size() == 0) 
    82                                                         break; 
    83                                         } catch (ResourceException e) { 
    84                                                 // TODO Auto-generated catch block 
    85                                                 e.printStackTrace(); 
    86                                         } 
     80                                        if(resourceManager.getResourcesByTypeWithStatus(StandardResourceType.Core, ResourceStatus.FREE).size() == 0) 
     81                                                break; 
     82 
    8783                                        Map<ResourceUnitName, ResourceUnit> choosenResources = chooseResourcesForExecution(resourceManager, task); 
    8884                                        if (choosenResources != null) { 

  • DCWoRMS/branches/coolemall/src/example/localplugin/coolemall/computebox2/CB2_FCFS_Random_SP.java

    r1396 r1415  
    88 
    99import schedframe.events.scheduling.SchedulingEvent; 
    10 import schedframe.exceptions.ResourceException; 
    1110import schedframe.resources.ResourceStatus; 
    1211import schedframe.resources.StandardResourceType; 
    … …  
    6160                                if (task.getStatus() == DCWormsTags.READY) { 
    6261 
    63                                         try { 
    64                                                 if(resourceManager.getResourcesByTypeWithStatus(StandardResourceType.Core, ResourceStatus.FREE).size() == 0) 
    65                                                         break; 
    66                                         } catch (ResourceException e) { 
    67                                                 // TODO Auto-generated catch block 
    68                                                 e.printStackTrace(); 
    69                                         } 
     62                                        if(resourceManager.getResourcesByTypeWithStatus(StandardResourceType.Core, ResourceStatus.FREE).size() == 0) 
     63                                                break; 
     64 
    7065                                        Map<ResourceUnitName, ResourceUnit> choosenResources = chooseResourcesForExecution(resourceManager, task); 
    7166                                        if (choosenResources != null) { 

  • DCWoRMS/branches/coolemall/src/example/timeestimation/coolemall/PhaseBasedTimeEstimationPlugin.java

    r1396 r1415  
    55 
    66import schedframe.events.scheduling.SchedulingEvent; 
     7import schedframe.resources.computing.ComputingResource; 
     8import schedframe.resources.computing.Core; 
     9import schedframe.resources.computing.Processor; 
     10import schedframe.resources.units.PEUnit; 
     11import schedframe.resources.units.ProcessingElements; 
    712import schedframe.resources.units.ResourceUnit; 
    813import schedframe.resources.units.ResourceUnitName; 
    9 import schedframe.scheduling.tasks.phases.ResourceConsumption; 
     14import schedframe.resources.units.StandardResourceUnitName; 
    1015import dcworms.schedframe.scheduling.ExecTask; 
    11 import dcworms.schedframe.scheduling.Executable; 
    1216import example.timeestimation.BaseTimeEstimationPlugin; 
    1317 
    14 public class PhaseTimeEstimationPlugin extends BaseTimeEstimationPlugin{ 
     18public class PhaseBasedTimeEstimationPlugin extends BaseTimeEstimationPlugin{ 
    1519 
    1620        /* 
    … …  
    1822         * Requested calculation should be done based on the resources allocated for the task, 
    1923         * task description and task completion percentage. 
     24         *  
     25         * Example implementation calculate the estimation based on processing power. 
     26         * There is also a simple assumption, that processing power is a linear function 
     27         * of number of allocated units and their speed. 
    2028         */ 
    2129        public double execTimeEstimation(SchedulingEvent event, ExecTask task, 
    2230                        Map<ResourceUnitName, ResourceUnit> allocatedResources, 
    2331                        double completionPercentage) { 
     32                 
    2433 
    25                 Executable exec = (Executable) task; 
     34                //String taskFreqString = task.getExecutionProfile().getCurrentResourceConsumption().getReferenceHardware().get("cpu_maxfreq"); 
     35                //double taskFreq = Double.valueOf(taskFreqString); 
    2636 
    27                 ResourceConsumption resConsumption = exec.getExecutionProfile().getCurrentResourceConsumption(); 
     37                double speed = 0; 
     38                PEUnit peUnit = (PEUnit) allocatedResources.get(StandardResourceUnitName.PE);    
     39                 
     40                try { 
     41                        ProcessingElements pes = (ProcessingElements) peUnit; 
     42                        for (ComputingResource compResource : pes) { 
     43                                if(compResource instanceof Core) { 
     44                                        Core core = (Core) compResource; 
     45                                        speed = core.getProcessor().getPowerInterface().getPState().getFrequency(); 
     46                                        break; 
     47                                } else if (compResource instanceof Processor) { 
     48                                        Processor processor = (Processor) compResource; 
     49                                        speed = processor.getPowerInterface().getPState().getFrequency(); 
     50                                        break; 
     51                                } 
     52                        }                
     53                } catch (Exception e){ 
     54                        speed = peUnit.getSpeed();                       
     55                } 
    2856 
    29                 double execTime = (1 - completionPercentage/100) * resConsumption.getDuration(); 
     57                //speed =  taskFreq; 
     58                int cnt = peUnit.getUsedAmount(); 
    3059 
     60                double execTime = (1 - completionPercentage/100) * task.getExecutionProfile().getCurrentResourceConsumption().getLenght() / (speed * cnt); 
     61 
     62                //double execTime = (1 - completionPercentage/100) * task.getExecutionProfile().getCurrentResourceConsumption().getDuration() * (taskFreq / currentFrequency); 
     63                //double execTime = (1 - completionPercentage/100) * task.getExecutionProfile().getCurrentResourceConsumption().getDuration(); 
     64                 
    3165                // if the result is very close to 0, but less then one millisecond then round this result to 0.001 
    3266                if (Double.compare(execTime, 0.001) < 0) { 
    … …  
    4074 
    4175} 
     76 
     77 

  • DCWoRMS/branches/coolemall/src/gridsim/dcworms/DCWormsTags.java

    r1381 r1415  
    1010        protected static final int DCWORMSBASE = 600;  
    1111         
    12         public static final int TO_COMP_RESOURCES = DCWORMSBASE - 4; 
     12        public static final int TO_RESOURCES = DCWORMSBASE - 4; 
    1313         
    1414        public static final int TO_SCHEDULERS = DCWORMSBASE - 3; 

  • DCWoRMS/branches/coolemall/src/schedframe/events/Event.java

    r477 r1415  
    11package schedframe.events; 
    22 
    3 import schedframe.events.scheduling.EventReason; 
    43 
    54public interface Event { 
    … …  
    98        public String getSource(); 
    109         
    11         public int getTag(); 
    12          
    1310        public Object getData(); 
    1411         

  • DCWoRMS/branches/coolemall/src/schedframe/events/EventCommand.java

    r1316 r1415  
    11package schedframe.events; 
     2 
     3import schedframe.resources.computing.profiles.energy.ResourceEvent; 
    24 
    35 
    … …  
    57public interface EventCommand { 
    68         
    7         public void execute(Event event); 
     9        public void execute(ResourceEvent event); 
    810} 

  • DCWoRMS/branches/coolemall/src/schedframe/events/EventHandler.java

    r477 r1415  
    22 
    33import schedframe.events.scheduling.SchedulingEvent; 
     4import schedframe.resources.computing.profiles.energy.ResourceEvent; 
    45 
    56public interface EventHandler { 
    67         
    7         public void handleResourceEvent(Event event); 
     8        public void handleResourceEvent(ResourceEvent event); 
    89         
    910        public void handleSchedulingEvent(SchedulingEvent event); 

  • DCWoRMS/branches/coolemall/src/schedframe/events/EventReason.java

    r477 r1415  
    1 package schedframe.events.scheduling; 
     1package schedframe.events; 
    22 
    33public enum EventReason { 
     4         
    45        //Reasons that caused given events 
    56        UNKNOWN, 
    … …  
    1213         
    1314        //TASK_CANCELED 
    14         RESERVATION_EXCEEDED, 
    1515        RESOURCES_EXCEEDED, 
    1616         

  • DCWoRMS/branches/coolemall/src/schedframe/events/EventType.java

    r477 r1415  
    55        public String getName(); 
    66         
    7         public int getTag(); 
    8          
    97} 

  • DCWoRMS/branches/coolemall/src/schedframe/events/ResourceEventCommand.java

    r1316 r1415  
    11package schedframe.events; 
    22 
     3import schedframe.resources.computing.profiles.energy.ResourceEvent; 
    34import schedframe.resources.devices.PhysicalResource; 
    45 
    … …  
    1112        } 
    1213 
    13         public void execute(Event event) { 
     14        public void execute(ResourceEvent event) { 
    1415                resource.getEventHandler().handleResourceEvent(event); 
    1516        } 

  • DCWoRMS/branches/coolemall/src/schedframe/events/scheduling/ResourceStateChangedEvent.java

    r1316 r1415  
    11package schedframe.events.scheduling; 
    22 
    3 import schedframe.events.EventType; 
     3import schedframe.resources.computing.profiles.energy.ResourceEventType; 
    44 
    5 public class ResourceStateChangedEvent  extends SchedulingEvent { 
     5public class ResourceStateChangedEvent extends SchedulingEvent { 
    66 
    7         protected String resourceName; 
    8         protected EventType eventType; 
     7        protected ResourceEventType eventType; 
    98         
    10         public ResourceStateChangedEvent(String resourceName, EventType eventType) { 
     9        public ResourceStateChangedEvent(ResourceEventType eventType) { 
    1110                super(SchedulingEventType.RESOURCE_STATE_CHANGED); 
    12                 this.resourceName = resourceName; 
    1311                this.eventType = eventType; 
    1412        } 
    1513 
    16         public String getResourceName() { 
    17                 return resourceName; 
    18         } 
    1914 
    20         public EventType getEventType() { 
     15        public ResourceEventType getResourceEventType() { 
    2116                return eventType; 
    2217        } 

  • DCWoRMS/branches/coolemall/src/schedframe/events/scheduling/SchedulingEvent.java

    r1316 r1415  
    22 
    33import schedframe.events.Event; 
     4import schedframe.events.EventReason; 
    45import schedframe.events.EventType; 
    56 
    … …  
    2526                        schedEventType = (SchedulingEventType)type; 
    2627                } catch(Exception e){ 
    27                         schedEventType = SchedulingEventType.RESOURCE_STATE_CHANGED; 
     28                        schedEventType = null; 
    2829                } 
    2930                return schedEventType; 
    … …  
    4243        } 
    4344 
    44         public int getTag() { 
    45                 return type.getTag(); 
    46         } 
    47  
    4845        public Object getData() { 
    4946                return null; 

  • DCWoRMS/branches/coolemall/src/schedframe/events/scheduling/SchedulingEventCommand.java

    r1316 r1415  
    11package schedframe.events.scheduling; 
    22 
    3 import schedframe.events.Event; 
    43import schedframe.events.EventCommand; 
    54import schedframe.resources.computing.ComputingResource; 
     5import schedframe.resources.computing.profiles.energy.ResourceEvent; 
    66 
    77public class SchedulingEventCommand implements EventCommand { 
    … …  
    1313        } 
    1414         
    15         public void execute(Event event) { 
    16                 SchedulingEvent ev = new ResourceStateChangedEvent(compResource.getFullName(), event.getType()); 
     15        public void execute(ResourceEvent event) { 
     16                SchedulingEvent ev = new ResourceStateChangedEvent(event.getType()); 
    1717                ev.setSource(compResource.getFullName()); 
    1818                compResource.getEventHandler().handleSchedulingEvent(ev); 

  • DCWoRMS/branches/coolemall/src/schedframe/events/scheduling/SchedulingEventType.java

    r1360 r1415  
    66 
    77        // task related 
    8         TASK_FINISHED(1), 
    9         TASK_FAILED(2), 
    10         TASK_CANCELED(4), 
    11         TASK_ARRIVED(8), 
    12         TASK_PAUSED(16), 
    13         TASK_RESUMED(32), 
    14         TASK_MOVED(64), 
    15         START_TASK_EXECUTION(128), 
    16         TASK_REQUESTED_TIME_EXPIRED(256), 
     8        TASK_FINISHED, 
     9        TASK_FAILED, 
     10        TASK_CANCELED, 
     11        TASK_ARRIVED, 
     12        TASK_PAUSED, 
     13        TASK_RESUMED, 
     14        TASK_MOVED, 
     15        TASK_EXECUTION_CHANGED, 
     16        START_TASK_EXECUTION, 
     17        TASK_REQUESTED_TIME_EXPIRED, 
    1718 
    1819        //job related 
    19         JOB_ARRIVED(512), 
    20         JOB_FINISHED(1024), 
    21         JOB_FAILED(2048), 
    22         JOB_CANCELED(4096), 
     20        JOB_ARRIVED, 
     21        JOB_FINISHED, 
     22        JOB_FAILED, 
     23        JOB_CANCELED, 
    2324 
    2425        //time related 
    25         TIMER(8192), 
     26        TIMER, 
     27                 
     28        //resource related 
     29        RESOURCE_FAILED, 
     30        //provider related (relevant to grid scheduling) 
     31        PROVIDER_FAILED, 
     32 
     33        RESOURCE_STATE_CHANGED, 
    2634         
    27         //reservation related 
    28         RESERVATION_ACTIVE(16384), 
    29         RESERVATION_FINISHED(32768), 
    30         RESERVATION_FAILED(65536), 
    31         RESERVATION_EXPIRED(131072), 
    32          
    33         //resource related 
    34         RESOURCE_FAILED(262144), 
    35         //provider related (relevant to grid scheduling) 
    36         PROVIDER_FAILED(524288), 
     35        POWER_LIMIT_EXCEEDED; 
    3736 
    38         RESOURCE_STATE_CHANGED(1048576), 
    39          
    40         POWER_LIMIT_EXCEEDED(2097152) 
    41         ; 
    42          
    43         protected int tag; 
    44          
    45         private SchedulingEventType(int tag){ 
    46                 this.tag = tag; 
    47         } 
    48          
    49         public int getTag(){ 
    50                 return this.tag; 
    51         } 
    5237         
    5338        public String getName(){ 

  • DCWoRMS/branches/coolemall/src/schedframe/events/scheduling/TaskCanceledEvent.java

    r477 r1415  
    22 
    33import java.util.List; 
     4 
     5import schedframe.events.EventReason; 
    46 
    57 

  • DCWoRMS/branches/coolemall/src/schedframe/resources/computing/ComputingResource.java

    r1396 r1415  
    99import java.util.Properties; 
    1010 
    11 import schedframe.events.Event; 
    1211import schedframe.events.EventHandler; 
     12import schedframe.events.EventReason; 
    1313import schedframe.events.ResourceEventCommand; 
    14 import schedframe.events.scheduling.EventReason; 
    1514import schedframe.events.scheduling.ResourceStateChangedEvent; 
    1615import schedframe.events.scheduling.SchedulingEvent; 
    … …  
    2120import schedframe.resources.computing.extensions.Extension; 
    2221import schedframe.resources.computing.extensions.ExtensionListImpl; 
    23 import schedframe.resources.computing.profiles.energy.EnergyEvent; 
    24 import schedframe.resources.computing.profiles.energy.EnergyEventType; 
     22import schedframe.resources.computing.profiles.energy.ResourceEvent; 
     23import schedframe.resources.computing.profiles.energy.ResourceEventType; 
    2524import schedframe.resources.computing.profiles.energy.EnergyExtension; 
    2625import schedframe.resources.computing.profiles.load.LoadExtension; 
    … …  
    117116        } 
    118117         
    119         private void triggerEventUp(Event event) { 
     118        private void triggerEventUp(ResourceEvent event) { 
    120119                if(parent != null) 
    121120                        parent.handleEvent(event); 
    122121        } 
    123122 
    124         public void handleEvent(Event event){ 
     123        public void handleEvent(ResourceEvent event){ 
    125124                ResourceEventCommand rec = new ResourceEventCommand(this); 
    126125                rec.execute(event); 
    … …  
    227226        class ComputingResourceEventHandler implements EventHandler{ 
    228227                 
    229                 public void handleResourceEvent(Event event){ 
     228                public void handleResourceEvent(ResourceEvent event){ 
    230229                        if (extensionList != null) { 
    231230                                for (Extension extension: extensionList) { 
    … …  
    254253                                //scheduler.sim_cancel(filter, null); 
    255254                                ResourceStateChangedEvent rscEvent = (ResourceStateChangedEvent) event; 
    256                                 EnergyEventType eeType = (EnergyEventType)rscEvent.getEventType(); 
     255                                ResourceEventType reType = rscEvent.getResourceEventType(); 
    257256                                //scheduler.sendInternal(GridSimTags.SCHEDULE_NOW, DCWormsTags.UPDATE_PROCESSING, src); 
    258                                 switch(eeType){ 
     257                                switch(reType){ 
    259258                                 
    260                                         case RESOURCE_UTILIZATION_CHANGED: { 
     259                                        case UTILIZATION_CHANGED: { 
    261260                                                scheduler.sendInternal(GridSimTags.SCHEDULE_NOW, DCWormsTags.UPDATE_PROCESSING, src); 
    262261                                                break; 
    263262                                        } 
    264                                         case FREQUENCY_CHANGED: { 
     263                                        case CPU_FREQUENCY_CHANGED: { 
    265264                                                scheduler.sendInternal(GridSimTags.SCHEDULE_NOW, DCWormsTags.UPDATE_PROCESSING, src); 
    266265                                                break; 
    … …  
    286285                } 
    287286                ResourceEventCommand rec = new ResourceEventCommand(this); 
    288                 EnergyEvent event = new EnergyEvent(EnergyEventType.AIRFLOW_STATE_CHANGED, "Resource controller"); 
     287                ResourceEvent event = new ResourceEvent(ResourceEventType.AIRFLOW_STATE_CHANGED, "Resource controller"); 
    289288                event.setReason(EventReason.SIM_INIT); 
    290289                rec.execute(event); 
    291290                /*ResourceEventCommand*/ rec = new ResourceEventCommand(this); 
    292                 /*EnergyEvent*/ event = new EnergyEvent(EnergyEventType.POWER_STATE_CHANGED, "Resource controller"); 
     291                /*ResourceEvent*/ event = new ResourceEvent(ResourceEventType.POWER_STATE_CHANGED, "Resource controller"); 
    293292                event.setReason(EventReason.SIM_INIT); 
    294293                rec.execute(event); 
    295294                 
    296295                rec = new ResourceEventCommand(this); 
    297                 event = new EnergyEvent(EnergyEventType.TEMPERATURE_CHANGED, "Resource controller"); 
     296                event = new ResourceEvent(ResourceEventType.TEMPERATURE_CHANGED, "Resource controller"); 
    298297                event.setReason(EventReason.SIM_INIT); 
    299298                rec.execute(event); 
    … …  
    302301                if(li != null){ 
    303302                        ResourceLoadCalendar rlc = li.getLoadCalendar(); 
    304                         LinkedList<TimestampUtilization> ll = rlc.getLoadDistribution(); 
    305                         for(TimestampUtilization tu: ll){ 
    306                                 DataCenterWorkloadSimulator.getEventManager().sendToResource(getFullName(), tu.getStartTime(), new EnergyEvent(EnergyEventType.RESOURCE_UTILIZATION_CHANGED, getFullName())); 
    307                                 DataCenterWorkloadSimulator.getEventManager().sendToResource(getFullName(), tu.getEndTime(), new EnergyEvent(EnergyEventType.RESOURCE_UTILIZATION_CHANGED, getFullName())); 
     303                        LinkedList<TimestampUtilization> ld = rlc.getLoadDistribution(); 
     304                        for(TimestampUtilization tu: ld){ 
     305                                DataCenterWorkloadSimulator.getEventManager().sendToResource(getFullName(), tu.getStartTime(), new ResourceEvent(ResourceEventType.UTILIZATION_CHANGED, getFullName())); 
     306                                DataCenterWorkloadSimulator.getEventManager().sendToResource(getFullName(), tu.getEndTime(), new ResourceEvent(ResourceEventType.UTILIZATION_CHANGED, getFullName())); 
    308307                        }                                        
    309308                } 

  • DCWoRMS/branches/coolemall/src/schedframe/resources/computing/profiles/energy/EnergyExtension.java

    r1396 r1415  
    1515import schedframe.resources.computing.profiles.energy.power.PowerInterfaceFactory; 
    1616import schedframe.resources.computing.profiles.energy.power.PowerProfile; 
     17import schedframe.resources.computing.profiles.energy.power.PowerStateName; 
    1718import schedframe.resources.computing.profiles.energy.power.ui.PowerInterface; 
    1819import schedframe.resources.computing.profiles.energy.thermal.ThermalInterfaceFactory; 
    … …  
    110111                if(powerProfile == null || powerProfile.getEnergyEstimationPlugin() == null) 
    111112                        return false; 
    112                 if(event.getType().getName().equals(EnergyEventType.POWER_STATE_CHANGED.getName())) 
    113                         return true; 
    114                 else if(event.getType().getName().equals(EnergyEventType.FREQUENCY_CHANGED.getName())) 
    115                         return true; 
    116                 else if(event.getType().getName().equals(EnergyEventType.TASK_STARTED.getName())) 
    117                         return true; 
    118                 else if(event.getType().getName().equals(EnergyEventType.TASK_FINISHED.getName())) 
    119                         return true; 
    120                 else if(event.getType().getName().equals(EnergyEventType.RESOURCE_UTILIZATION_CHANGED.getName())) 
    121                         return true; 
    122          
    123                 if(event.getType().getName().equals(EnergyEventType.AIRFLOW_STATE_CHANGED.getName())) 
    124                         return true; 
    125                 if(event.getType().getName().equals(EnergyEventType.TEMPERATURE_CHANGED.getName())) 
     113                if(event.getType().getName().equals(ResourceEventType.POWER_STATE_CHANGED.getName())) 
     114                        return true; 
     115                else if(event.getType().getName().equals(ResourceEventType.CPU_FREQUENCY_CHANGED.getName())) 
     116                        return true; 
     117                else if(event.getType().getName().equals(ResourceEventType.TASK_STARTED.getName())) 
     118                        return true; 
     119                else if(event.getType().getName().equals(ResourceEventType.TASK_FINISHED.getName())) 
     120                        return true; 
     121                else if(event.getType().getName().equals(ResourceEventType.UTILIZATION_CHANGED.getName())) 
     122                        return true; 
     123         
     124                if(event.getType().getName().equals(ResourceEventType.AIRFLOW_STATE_CHANGED.getName())) 
     125                        return true; 
     126                if(event.getType().getName().equals(ResourceEventType.TEMPERATURE_CHANGED.getName())) 
    126127                        return true; 
    127128                 
    … …  
    131132        public void handleEvent(Event event) { 
    132133                 
    133                 EnergyEvent enEvent = (EnergyEvent)event; 
     134                ResourceEvent resEvent = (ResourceEvent)event; 
    134135                double power = 0; 
    135136                boolean status = false; 
    136137                try{ 
    137                         switch (enEvent.getType()) { 
     138                        switch (resEvent.getType()) { 
    138139                         
     140                        case UPDATE_POWER_STATE: 
     141                                PowerStateName newPowerState = (PowerStateName) resEvent.getData(); 
     142                                powerInterface.setPowerState(newPowerState); 
     143                                break; 
     144                                 
    139145                        case POWER_STATE_CHANGED: 
    140                                 power = powerProfile.getEnergyEstimationPlugin().estimatePowerConsumption(enEvent, new JobRegistryImpl(resource.getFullName()), resource);                       
    141                                 status = powerProfile.addToPowerUsageHistory(power); 
    142                                 break; 
    143                                  
    144                         case FREQUENCY_CHANGED: 
    145                                 power = powerProfile.getEnergyEstimationPlugin().estimatePowerConsumption(enEvent, new JobRegistryImpl(resource.getFullName()), resource); 
     146                                power = powerProfile.getEnergyEstimationPlugin().estimatePowerConsumption(resEvent, new JobRegistryImpl(resource.getFullName()), resource);                      
     147                                status = powerProfile.addToPowerUsageHistory(power); 
     148                                break; 
     149                                 
     150                        case CPU_FREQUENCY_CHANGED: 
     151                                power = powerProfile.getEnergyEstimationPlugin().estimatePowerConsumption(resEvent, new JobRegistryImpl(resource.getFullName()), resource); 
    146152                                status = powerProfile.addToPowerUsageHistory(power); 
    147153                                break; 
    148154                                 
    149155                        case TASK_STARTED: 
    150                                 power = powerProfile.getEnergyEstimationPlugin().estimatePowerConsumption(enEvent, new JobRegistryImpl(resource.getFullName()), resource); 
     156                                power = powerProfile.getEnergyEstimationPlugin().estimatePowerConsumption(resEvent, new JobRegistryImpl(resource.getFullName()), resource); 
    151157                                status = powerProfile.addToPowerUsageHistory(power); 
    152158                                break; 
    153159         
    154160                        case TASK_FINISHED: 
    155                                 power = powerProfile.getEnergyEstimationPlugin().estimatePowerConsumption(enEvent, new JobRegistryImpl(resource.getFullName()), resource); 
    156                                 status = powerProfile.addToPowerUsageHistory(power); 
    157                                 break; 
    158                                  
    159                         case RESOURCE_UTILIZATION_CHANGED: 
    160                                 power = powerProfile.getEnergyEstimationPlugin().estimatePowerConsumption(enEvent, new JobRegistryImpl(resource.getFullName()), resource); 
     161                                power = powerProfile.getEnergyEstimationPlugin().estimatePowerConsumption(resEvent, new JobRegistryImpl(resource.getFullName()), resource); 
     162                                status = powerProfile.addToPowerUsageHistory(power); 
     163                                break; 
     164                                 
     165                        case UTILIZATION_CHANGED: 
     166                                power = powerProfile.getEnergyEstimationPlugin().estimatePowerConsumption(resEvent, new JobRegistryImpl(resource.getFullName()), resource); 
    161167                                status = powerProfile.addToPowerUsageHistory(power); 
    162168                                break; 
    163169                                 
    164170                        case AIRFLOW_STATE_CHANGED: 
    165                                 double airflow = powerProfile.getEnergyEstimationPlugin().estimateAirflow(enEvent, new JobRegistryImpl(resource.getFullName()), resource); 
     171                                double airflow = powerProfile.getEnergyEstimationPlugin().estimateAirflow(resEvent, new JobRegistryImpl(resource.getFullName()), resource); 
    166172                                airflowProfile.addToAirFlowHistory(airflow); 
    167173                                break; 
    168174                                 
    169175                        case TEMPERATURE_CHANGED: 
    170                                 double temperature = powerProfile.getEnergyEstimationPlugin().estimateTemperature(enEvent, new JobRegistryImpl(resource.getFullName()), resource); 
     176                                double temperature = powerProfile.getEnergyEstimationPlugin().estimateTemperature(resEvent, new JobRegistryImpl(resource.getFullName()), resource); 
    171177                                thermalProfile.addToTemperatureHistory(temperature); 
    172178                                break; 
    … …  
    176182                } 
    177183                if(status){ 
    178                         DataCenterWorkloadSimulator.getEventManager().sendToResources(resource.getType(), 0, new EnergyEvent(EnergyEventType.TEMPERATURE_CHANGED, resource.getFullName())); 
     184                        DataCenterWorkloadSimulator.getEventManager().sendToResources(resource.getType(), 0, new ResourceEvent(ResourceEventType.TEMPERATURE_CHANGED, resource.getFullName())); 
    179185                } 
    180186        } 

  • DCWoRMS/branches/coolemall/src/schedframe/resources/computing/profiles/energy/ResourceEvent.java

    r1320 r1415  
    22 
    33import schedframe.events.Event; 
     4import schedframe.events.EventReason; 
    45import schedframe.events.EventType; 
    5 import schedframe.events.scheduling.EventReason; 
    66 
    77 
    8 public class EnergyEvent implements Event{ 
     8public class ResourceEvent implements Event{ 
    99 
    1010        protected EventType type; 
    1111        protected EventReason reason; 
     12        protected String source; 
    1213        protected Object data; 
    13         protected String source; 
    1414 
    15         public EnergyEvent(EventType eventType, String source){ 
     15        public ResourceEvent(EventType eventType, String source){ 
    1616                this.type = eventType; 
    1717                this.source = source; 
    … …  
    1919        } 
    2020         
    21         public EnergyEvent(EventType eventType, Object data, String source){ 
     21        public ResourceEvent(EventType eventType, Object data, String source){ 
    2222                this.type = eventType; 
    2323                this.data = data; 
    … …  
    2626        } 
    2727         
    28         public EnergyEventType getType() { 
    29                 EnergyEventType enEventType = null;  
     28        public ResourceEventType getType() { 
     29                ResourceEventType resEventType;  
    3030                try{ 
    31                         enEventType = (EnergyEventType)type; 
     31                        resEventType = (ResourceEventType)type; 
    3232                } catch(Exception e){ 
    33  
     33                        resEventType = null;  
    3434                } 
    35                 return enEventType; 
    36  
    37         } 
    38  
    39         public int getTag() { 
    40                 return type.getTag(); 
     35                return resEventType; 
    4136        } 
    4237 

  • DCWoRMS/branches/coolemall/src/schedframe/resources/computing/profiles/energy/ResourceEventType.java

    r1320 r1415  
    33import schedframe.events.EventType; 
    44 
    5 public enum EnergyEventType implements EventType { 
     5public enum ResourceEventType implements EventType { 
    66         
    7         TASK_FINISHED(1), 
    8         TASK_FAILED(2), 
    9         TASK_CANCELED(4), 
    10         TASK_STARTED(8), 
     7        TASK_STARTED, 
     8        TASK_FINISHED, 
    119 
    12         TIMER(16), 
     10        POWER_STATE_CHANGED, 
     11        CPU_FREQUENCY_CHANGED, 
     12        AIRFLOW_STATE_CHANGED, 
     13         
     14        UTILIZATION_CHANGED, 
     15         
     16        TEMPERATURE_CHANGED, 
     17         
     18        UPDATE_POWER_STATE; 
    1319 
    14         POWER_STATE_CHANGED(32), 
    15         FREQUENCY_CHANGED(64), 
    16          
    17         AIRFLOW_STATE_CHANGED(256), 
    18          
    19         RESOURCE_FAILED(512), 
    20          
    21         RESOURCE_UTILIZATION_CHANGED(1024), 
    22          
    23         TEMPERATURE_CHANGED(2048) 
    24          
    25         ; 
    26  
    27         protected int tag; 
    28          
    29         public int getTag() { 
    30                 return tag; 
    31         } 
    32  
    33         private EnergyEventType(int tag){ 
    34                 this.tag = tag; 
    35         } 
    36          
    3720        public String getName(){ 
    3821                return toString(); 

  • DCWoRMS/branches/coolemall/src/schedframe/resources/computing/profiles/energy/airthroughput/ui/ComputingResourceAirflowInterface.java

    r1396 r1415  
    88import schedframe.Parameters; 
    99import schedframe.resources.computing.ComputingResource; 
    10 import schedframe.resources.computing.profiles.energy.EnergyEvent; 
    11 import schedframe.resources.computing.profiles.energy.EnergyEventType; 
     10import schedframe.resources.computing.profiles.energy.ResourceEvent; 
     11import schedframe.resources.computing.profiles.energy.ResourceEventType; 
    1212import schedframe.resources.computing.profiles.energy.airthroughput.AirflowValue; 
    1313import schedframe.resources.computing.profiles.energy.airthroughput.AirflowProfile; 
    … …  
    3737                         
    3838                        //TO DO - notifications should be called for all resources starting form the lowest layer 
    39                         resource.handleEvent(new EnergyEvent(EnergyEventType.AIRFLOW_STATE_CHANGED, resource.getFullName())); 
    40                         resource.handleEvent(new EnergyEvent(EnergyEventType.POWER_STATE_CHANGED, resource.getFullName())); 
     39                        resource.handleEvent(new ResourceEvent(ResourceEventType.AIRFLOW_STATE_CHANGED, resource.getFullName())); 
     40                        resource.handleEvent(new ResourceEvent(ResourceEventType.POWER_STATE_CHANGED, resource.getFullName())); 
    4141                        return true; 
    4242                } 

  • DCWoRMS/branches/coolemall/src/schedframe/resources/computing/profiles/energy/power/StandardPowerStateName.java

    r1396 r1415  
    88        SLEEP, 
    99        SUSPEND, 
    10         HIBERNATE; 
     10        HIBERNATE, 
     11        BOOT, 
     12        POWEROFF; 
    1113 
    1214        public String getLabel() { 

  • DCWoRMS/branches/coolemall/src/schedframe/resources/computing/profiles/energy/power/plugin/EnergyEstimationPlugin.java

    r1396 r1415  
    22 
    33import schedframe.Plugin; 
    4 import schedframe.resources.computing.profiles.energy.EnergyEvent; 
     4import schedframe.resources.computing.profiles.energy.ResourceEvent; 
    55import schedframe.resources.devices.PhysicalResource; 
    66import schedframe.scheduling.manager.tasks.JobRegistry; 
    … …  
    88public interface EnergyEstimationPlugin extends Plugin { 
    99         
    10         public double estimatePowerConsumption(EnergyEvent event, JobRegistry jobRegistry, PhysicalResource resource); 
     10        public double estimatePowerConsumption(ResourceEvent event, JobRegistry jobRegistry, PhysicalResource resource); 
    1111 
    12         public double estimateAirflow(EnergyEvent event, JobRegistry jobRegistry, PhysicalResource resource); 
     12        public double estimateAirflow(ResourceEvent event, JobRegistry jobRegistry, PhysicalResource resource); 
    1313 
    14         public double estimateTemperature(EnergyEvent event, JobRegistry jobRegistry, PhysicalResource resource); 
     14        public double estimateTemperature(ResourceEvent event, JobRegistry jobRegistry, PhysicalResource resource); 
    1515 
    1616} 

  • DCWoRMS/branches/coolemall/src/schedframe/resources/computing/profiles/energy/power/ui/ComputingResourcePowerInterface.java

    r1396 r1415  
    99import schedframe.resources.ResourceStatus; 
    1010import schedframe.resources.computing.ComputingResource; 
    11 import schedframe.resources.computing.profiles.energy.EnergyEvent; 
    12 import schedframe.resources.computing.profiles.energy.EnergyEventType; 
     11import schedframe.resources.computing.profiles.energy.ResourceEvent; 
     12import schedframe.resources.computing.profiles.energy.ResourceEventType; 
    1313import schedframe.resources.computing.profiles.energy.power.PowerProfile; 
    1414import schedframe.resources.computing.profiles.energy.power.PowerState; 
    … …  
    4949                        } 
    5050                        //notifications from all levels 
    51                         resource.handleEvent(new EnergyEvent(EnergyEventType.POWER_STATE_CHANGED, resource.getFullName())); 
     51                        resource.handleEvent(new ResourceEvent(ResourceEventType.POWER_STATE_CHANGED, resource.getFullName())); 
    5252 
    5353                        //notification from last level 

  • DCWoRMS/branches/coolemall/src/schedframe/resources/computing/profiles/energy/power/ui/NodePowerInterface.java

    r1384 r1415  
    33 
    44 
     5import java.util.List; 
     6 
    57import schedframe.resources.ResourceStatus; 
    68import schedframe.resources.computing.ComputingResource; 
    79import schedframe.resources.computing.Node; 
    8 import schedframe.resources.computing.profiles.energy.EnergyEvent; 
    9 import schedframe.resources.computing.profiles.energy.EnergyEventType; 
     10import schedframe.resources.computing.profiles.energy.ResourceEvent; 
     11import schedframe.resources.computing.profiles.energy.ResourceEventType; 
    1012import schedframe.resources.computing.profiles.energy.power.PowerProfile; 
     13import schedframe.resources.computing.profiles.energy.power.PowerState; 
    1114import schedframe.resources.computing.profiles.energy.power.PowerStateName; 
    1215import schedframe.resources.computing.profiles.energy.power.StandardPowerStateName; 
     16import schedframe.resources.computing.profiles.energy.power.Transition; 
     17import simulator.DataCenterWorkloadSimulator; 
    1318 
    1419public class NodePowerInterface extends ComputingResourcePowerInterface{ 
    … …  
    2631                         
    2732                        Node node = (Node) resource; 
    28                         for(ComputingResource child:node.getProcessors()){ 
     33                        for(ComputingResource child: node.getProcessors()){ 
    2934                                if(child.getPowerInterface() != null){ 
    3035                                        child.getPowerInterface().setPowerState(state);  
    … …  
    3944                        } 
    4045         
    41                         node.handleEvent(new EnergyEvent(EnergyEventType.POWER_STATE_CHANGED, node.getFullName())); 
     46                        node.handleEvent(new ResourceEvent(ResourceEventType.POWER_STATE_CHANGED, node.getFullName())); 
    4247 
    4348                        //node.handleEvent(new EnergyEvent(EnergyEventType.POWER_STATE_CHANGED, computingNode.getName())); 
    … …  
    4853 
    4954        public void turnOn(){ 
     55                /*double timePenalty = getTransitionTime(currentPowerState, StandardPowerStateName.ON); 
     56                setPowerState(StandardPowerStateName.BOOT); 
     57                DataCenterWorkloadSimulator.getEventManager().sendToResource(resource.getFullName(), timePenalty, new ResourceEvent(ResourceEventType.UPDATE_POWER_STATE, StandardPowerStateName.ON, resource.getFullName()));*/ 
    5058                setPowerState(StandardPowerStateName.ON); 
    5159        } 
    5260         
    5361        public void turnOff(){ 
     62                /*double timePenalty = getTransitionTime(currentPowerState, StandardPowerStateName.OFF); 
     63                setPowerState(StandardPowerStateName.POWEROFF); 
     64                DataCenterWorkloadSimulator.getEventManager().sendToResource(resource.getFullName(), timePenalty, new ResourceEvent(ResourceEventType.UPDATE_POWER_STATE, StandardPowerStateName.OFF, resource.getFullName()));*/ 
    5465                setPowerState(StandardPowerStateName.OFF); 
    5566        } 
    5667 
     68        private double getTransitionTime(PowerStateName from, PowerStateName to){ 
     69                List<PowerState> availablePowerStates = getSupportedPowerStates(); 
     70                double timePenalty = 0; 
     71                for(PowerState ps : availablePowerStates){ 
     72                        if(ps.getName().getLabel().equals(from.getLabel())){ 
     73                                List<Transition> transitions = ps.getTransitions(); 
     74                                for(Transition t: transitions){ 
     75                                        if(t.getTo().getLabel().equals(to)){ 
     76                                                timePenalty = t.getTime(); 
     77                                        } 
     78                                } 
     79                        } 
     80                } 
     81                return timePenalty; 
     82        } 
    5783 
    5884 

  • DCWoRMS/branches/coolemall/src/schedframe/resources/computing/profiles/energy/power/ui/ProcessorPowerInterface.java

    r1299 r1415  
    66import schedframe.resources.ResourceStatus; 
    77import schedframe.resources.computing.ComputingResource; 
    8 import schedframe.resources.computing.profiles.energy.EnergyEvent; 
    9 import schedframe.resources.computing.profiles.energy.EnergyEventType; 
     8import schedframe.resources.computing.profiles.energy.ResourceEvent; 
     9import schedframe.resources.computing.profiles.energy.ResourceEventType; 
    1010import schedframe.resources.computing.profiles.energy.power.PState; 
    1111import schedframe.resources.computing.profiles.energy.power.PowerProfile; 
    … …  
    3333                                resource.setStatus(ResourceStatus.FREE); 
    3434                        } 
    35                         resource.handleEvent(new EnergyEvent(EnergyEventType.POWER_STATE_CHANGED, resource.getFullName()));              
     35                        resource.handleEvent(new ResourceEvent(ResourceEventType.POWER_STATE_CHANGED, resource.getFullName()));          
    3636                } 
    3737 
    … …  
    6767                        //speed.setAmount(Double.valueOf(currentPState.getFrequency()).intValue()); 
    6868                        //new ResourceEventCommand(resource).execute(EnergyEventType.FREQUENCY_CHANGED); 
    69                         resource.handleEvent(new EnergyEvent(EnergyEventType.FREQUENCY_CHANGED, resource.getFullName())); 
     69                        resource.handleEvent(new ResourceEvent(ResourceEventType.CPU_FREQUENCY_CHANGED, resource.getFullName())); 
    7070                        //resource.getScheduler().sendInternal(GridSimTags.SCHEDULE_NOW, DCWormsTags.UPDATE, resource.getName()); 
    7171                         

  • DCWoRMS/branches/coolemall/src/schedframe/resources/computing/profiles/load/LoadExtension.java

    r1285 r1415  
    77import schedframe.resources.computing.extensions.ExtensionException; 
    88import schedframe.resources.computing.extensions.ExtensionType; 
    9 import schedframe.resources.computing.profiles.energy.EnergyEvent; 
    10 import schedframe.resources.computing.profiles.energy.EnergyEventType; 
     9import schedframe.resources.computing.profiles.energy.ResourceEvent; 
     10import schedframe.resources.computing.profiles.energy.ResourceEventType; 
    1111import schedframe.resources.computing.profiles.load.ui.LoadInterface; 
    1212import schedframe.resources.devices.PhysicalResource; 
    … …  
    2929                if(loadProfile == null || loadProfile.getLoadEstimationPlugin() == null) 
    3030                        return false; 
    31                 if(event.getType().getName().equals(EnergyEventType.POWER_STATE_CHANGED.getName())) 
     31                if(event.getType().getName().equals(ResourceEventType.POWER_STATE_CHANGED.getName())) 
    3232                        return true; 
    33                 else if(event.getType().getName().equals(EnergyEventType.FREQUENCY_CHANGED.getName())) 
     33                else if(event.getType().getName().equals(ResourceEventType.CPU_FREQUENCY_CHANGED.getName())) 
    3434                        return true; 
    35                 else if(event.getType().getName().equals(EnergyEventType.TASK_STARTED.getName())) 
     35                else if(event.getType().getName().equals(ResourceEventType.TASK_STARTED.getName())) 
    3636                        return true; 
    37                 else if(event.getType().getName().equals(EnergyEventType.TASK_FINISHED.getName())) 
     37                else if(event.getType().getName().equals(ResourceEventType.TASK_FINISHED.getName())) 
    3838                        return true; 
    39                 else if(event.getType().getName().equals(EnergyEventType.RESOURCE_UTILIZATION_CHANGED.getName())) 
     39                else if(event.getType().getName().equals(ResourceEventType.UTILIZATION_CHANGED.getName())) 
    4040                        return true;             
    4141                else return false; 
    … …  
    4444        public void handleEvent(Event event) { 
    4545                 
    46                 EnergyEvent enEvent = (EnergyEvent)event; 
     46                ResourceEvent enEvent = (ResourceEvent)event; 
    4747                double load = 0; 
    4848                try{ 
    … …  
    5454                                break; 
    5555                                 
    56                         case FREQUENCY_CHANGED: 
     56                        case CPU_FREQUENCY_CHANGED: 
    5757                                load = loadProfile.getLoadEstimationPlugin().estimateUtlization(enEvent, new JobRegistryImpl(resource.getFullName()), resource); 
    5858                                loadProfile.addToLoadHistory(load); 
    … …  
    6969                                break; 
    7070                                 
    71                         case RESOURCE_UTILIZATION_CHANGED: 
     71                        case UTILIZATION_CHANGED: 
    7272                                load = loadProfile.getLoadEstimationPlugin().estimateUtlization(enEvent, new JobRegistryImpl(resource.getFullName()), resource); 
    7373                                loadProfile.addToLoadHistory(load); 

  • DCWoRMS/branches/coolemall/src/schedframe/resources/computing/profiles/load/plugin/LoadEstimationPlugin.java

    r1285 r1415  
    22 
    33import schedframe.Plugin; 
    4 import schedframe.resources.computing.profiles.energy.EnergyEvent; 
     4import schedframe.resources.computing.profiles.energy.ResourceEvent; 
    55import schedframe.resources.devices.PhysicalResource; 
    66import schedframe.scheduling.manager.tasks.JobRegistry; 
    … …  
    88public interface LoadEstimationPlugin extends Plugin { 
    99         
    10         public double estimateUtlization(EnergyEvent event, JobRegistry jobRegistry, PhysicalResource resource); 
     10        public double estimateUtlization(ResourceEvent event, JobRegistry jobRegistry, PhysicalResource resource); 
    1111 
    1212 

  • DCWoRMS/branches/coolemall/src/schedframe/resources/devices/Device.java

    r1396 r1415  
    11package schedframe.resources.devices; 
    22 
    3 import schedframe.events.Event; 
    43import schedframe.events.EventHandler; 
     4import schedframe.events.EventReason; 
    55import schedframe.events.ResourceEventCommand; 
    6 import schedframe.events.scheduling.EventReason; 
    76import schedframe.events.scheduling.SchedulingEvent; 
    87import schedframe.resources.ResourceStatus; 
    … …  
    1110import schedframe.resources.computing.extensions.Extension; 
    1211import schedframe.resources.computing.extensions.ExtensionListImpl; 
    13 import schedframe.resources.computing.profiles.energy.EnergyEvent; 
    14 import schedframe.resources.computing.profiles.energy.EnergyEventType; 
     12import schedframe.resources.computing.profiles.energy.ResourceEvent; 
     13import schedframe.resources.computing.profiles.energy.ResourceEventType; 
    1514import schedframe.resources.computing.profiles.energy.EnergyExtension; 
    1615import schedframe.resources.devices.description.DeviceDescription; 
    … …  
    4443        } 
    4544 
    46         public void handleEvent(Event event) { 
     45        public void handleEvent(ResourceEvent event) { 
    4746                ResourceEventCommand rec = new ResourceEventCommand(this); 
    4847                rec.execute(event); 
    … …  
    5150        class DeviceEventHandler implements EventHandler{ 
    5251                 
    53                 public void handleResourceEvent(Event event){ 
     52                public void handleResourceEvent(ResourceEvent event){ 
    5453                        if (extensionList != null) { 
    5554                                for (Extension extension : extensionList) { 
    … …  
    7574                 
    7675                ResourceEventCommand rec = new ResourceEventCommand(this); 
    77                 EnergyEvent event = new EnergyEvent(EnergyEventType.AIRFLOW_STATE_CHANGED, "Resource controller"); 
     76                ResourceEvent event = new ResourceEvent(ResourceEventType.AIRFLOW_STATE_CHANGED, "Resource controller"); 
    7877                event.setReason(EventReason.SIM_INIT); 
    7978                rec.execute(event); 
    8079                 
    8180                rec = new ResourceEventCommand(this); 
    82                 event = new EnergyEvent(EnergyEventType.POWER_STATE_CHANGED, "Resource controller"); 
     81                event = new ResourceEvent(ResourceEventType.POWER_STATE_CHANGED, "Resource controller"); 
    8382                event.setReason(EventReason.SIM_INIT); 
    8483                rec.execute(event); 
    8584                 
    8685                rec = new ResourceEventCommand(this); 
    87                 event = new EnergyEvent(EnergyEventType.TEMPERATURE_CHANGED, "Resource controller"); 
     86                event = new ResourceEvent(ResourceEventType.TEMPERATURE_CHANGED, "Resource controller"); 
    8887                event.setReason(EventReason.SIM_INIT); 
    8988                rec.execute(event); 

  • DCWoRMS/branches/coolemall/src/schedframe/resources/devices/DeviceAirflowInterface.java

    r1396 r1415  
    77 
    88import schedframe.Parameters; 
    9 import schedframe.resources.computing.profiles.energy.EnergyEvent; 
    10 import schedframe.resources.computing.profiles.energy.EnergyEventType; 
     9import schedframe.resources.computing.profiles.energy.ResourceEvent; 
     10import schedframe.resources.computing.profiles.energy.ResourceEventType; 
    1111import schedframe.resources.computing.profiles.energy.airthroughput.AirflowValue; 
    1212import schedframe.resources.computing.profiles.energy.airthroughput.AirflowProfile; 
    … …  
    3737                         
    3838                        //TO DO - notifications should be called for all resources starting form the lowest layer 
    39                         resource.handleEvent(new EnergyEvent(EnergyEventType.AIRFLOW_STATE_CHANGED, resource.getFullName())); 
    40                         resource.handleEvent(new EnergyEvent(EnergyEventType.POWER_STATE_CHANGED, resource.getFullName())); 
     39                        resource.handleEvent(new ResourceEvent(ResourceEventType.AIRFLOW_STATE_CHANGED, resource.getFullName())); 
     40                        resource.handleEvent(new ResourceEvent(ResourceEventType.POWER_STATE_CHANGED, resource.getFullName())); 
    4141                        return true; 
    4242                } 

  • DCWoRMS/branches/coolemall/src/schedframe/resources/devices/DevicePowerInterface.java

    r1380 r1415  
    77 
    88import schedframe.Parameters; 
    9 import schedframe.resources.computing.profiles.energy.EnergyEvent; 
    10 import schedframe.resources.computing.profiles.energy.EnergyEventType; 
     9import schedframe.resources.computing.profiles.energy.ResourceEvent; 
     10import schedframe.resources.computing.profiles.energy.ResourceEventType; 
    1111import schedframe.resources.computing.profiles.energy.power.PowerProfile; 
    1212import schedframe.resources.computing.profiles.energy.power.PowerState; 
    … …  
    3232                        currentPowerState = state; 
    3333 
    34                         resource.handleEvent(new EnergyEvent(EnergyEventType.POWER_STATE_CHANGED, resource.getFullName())); 
     34                        resource.handleEvent(new ResourceEvent(ResourceEventType.POWER_STATE_CHANGED, resource.getFullName())); 
    3535 
    3636                        return true; 

  • DCWoRMS/branches/coolemall/src/schedframe/resources/devices/Fan.java

    r1274 r1415  
    44import java.util.List; 
    55 
     6import schedframe.resources.computing.ComputingResource; 
    67import schedframe.resources.devices.description.DeviceDescription; 
    78 
    … …  
    1213        public Fan(DeviceDescription devDesc) { 
    1314                super(devDesc); 
    14                 this.chilledResources = new ArrayList<String>(); 
    1515        } 
    1616         
    1717        public List<String> getChilledResources(){ 
     18                if(chilledResources == null){ 
     19                        List<String> resNames =  new ArrayList<String>(); 
     20                        for(ComputingResource compRes: this.getComputingResource().getChildren()){ 
     21                                resNames.add(compRes.getFullName()); 
     22                        } 
     23                        return resNames; 
     24                } 
    1825                return chilledResources; 
    1926        } 

  • DCWoRMS/branches/coolemall/src/schedframe/resources/devices/PhysicalResource.java

    r1396 r1415  
    1212import schedframe.resources.computing.extensions.ExtensionType; 
    1313import schedframe.resources.computing.profiles.energy.EnergyExtension; 
     14import schedframe.resources.computing.profiles.energy.ResourceEvent; 
    1415import schedframe.resources.computing.profiles.energy.airthroughput.ui.AirflowInterface; 
    1516import schedframe.resources.computing.profiles.energy.power.ui.PowerInterface; 
    … …  
    2829 
    2930         
    30         public abstract void handleEvent(Event event); 
     31        public abstract void handleEvent(ResourceEvent event); 
    3132         
    3233        public abstract EventHandler getEventHandler(); 

  • DCWoRMS/branches/coolemall/src/schedframe/resources/devices/description/PhysicalResourceDescription.java

    r1396 r1415  
    3030import schemas.PowerUsage; 
    3131import schemas.Profile; 
     32import schemas.StringValueWithUnit; 
    3233import simulator.utils.InstanceFactory; 
    3334import example.energy.DefaultEnergyEstimationPlugin; 
    … …  
    8283                                } 
    8384                                Parameters params = extractParameters(powerProfileCharacteristic.getEnergyEstimationPlugin().getParameter()); 
     85                                if(powerProfileCharacteristic.getEnergyEstimationPlugin().getPowerCapLevel() != null) { 
     86                                        Parameter param = new Parameter("powerCapLevel"); 
     87                                        StringValueWithUnit sv = new StringValueWithUnit(); 
     88                                        sv.setContent(String.valueOf(powerProfileCharacteristic.getEnergyEstimationPlugin().getPowerCapLevel().getContent())); 
     89                                        sv.setUnit(powerProfileCharacteristic.getEnergyEstimationPlugin().getPowerCapLevel().getUnit()); 
     90                                        param.add(sv); 
     91                                         
     92                                        if(params == null) 
     93                                                params = new Parameters(); 
     94                                        params.put("powerCapLevel", param); 
     95                                } 
     96                                if(powerProfileCharacteristic.getEnergyEstimationPlugin().getPowerFloorLevel() != null) { 
     97                                        Parameter param = new Parameter("powerFloorLevel"); 
     98                                        StringValueWithUnit sv = new StringValueWithUnit(); 
     99                                        sv.setContent(String.valueOf(powerProfileCharacteristic.getEnergyEstimationPlugin().getPowerFloorLevel().getContent())); 
     100                                        sv.setUnit(powerProfileCharacteristic.getEnergyEstimationPlugin().getPowerFloorLevel().getUnit()); 
     101                                        param.add(sv); 
     102                                         
     103                                        if(params == null) 
     104                                                params = new Parameters(); 
     105                                        params.put("powerFloorLevel", param); 
     106                                } 
    84107                                energyEstimationPlugin.init(params); 
    85108                        } 

  • DCWoRMS/branches/coolemall/src/schedframe/resources/units/StandardResourceUnitName.java

    r1396 r1415  
    3737    COST("cost"), 
    3838     
    39     PE("processingElement"); 
     39    PE("processingelement"); 
    4040 
    4141     

  • DCWoRMS/branches/coolemall/src/schedframe/scheduling/ResourceItem.java

    r1396 r1415  
    11package schedframe.scheduling; 
    22 
    3 import java.util.HashSet; 
    43import java.util.LinkedList; 
    54import java.util.List; 
    65import java.util.Map; 
    76import java.util.Set; 
     7import java.util.TreeSet; 
    88 
    99import schedframe.resources.computing.ComputingResource; 
    … …  
    1616 
    1717        protected Map<ResourceUnitName, ResourceUnit> usedResources; 
    18         protected Set<String> visitedResources; 
     18        protected Set<String> resourceNames; 
    1919 
    2020        public ResourceItem(Map<ResourceUnitName, ResourceUnit> usedResources){ 
    2121                this.usedResources = usedResources; 
    22                 this.visitedResources = new HashSet<String>(); 
     22                this.resourceNames = new TreeSet<String>(); 
    2323                saveResourceNames(); 
    2424        } 
    … …  
    2929         
    3030        public Set<String> getResourceNames(){ 
    31                 return visitedResources; 
     31                return resourceNames; 
    3232        } 
    3333         
    … …  
    4343                                List<ComputingResource> resources = compResource.getChildren(); 
    4444                                if(resources.isEmpty()){ 
    45                                         if(!visitedResources.contains(compResource.getFullName())){ 
    46                                                 visitedResources.add(compResource.getFullName()); 
     45                                        if(!resourceNames.contains(compResource.getFullName())){ 
     46                                                resourceNames.add(compResource.getFullName()); 
    4747                                        } 
    4848                                } else { 

  • DCWoRMS/branches/coolemall/src/schedframe/scheduling/Scheduler.java

    r1362 r1415  
    6363                List<Integer> schedRes = GridSim.getGridResourceList(); 
    6464                schedRes.add(schedulerIdObj); 
    65  
    66                 /*if (supportsAR) { 
    67                         res = GridSim.getAdvancedReservationList(); 
    68                         res.add(resIdObj); 
    69                 } */ 
    70  
    7165        } 
    7266         

  • DCWoRMS/branches/coolemall/src/schedframe/scheduling/manager/resources/ClusterResourceManager.java

    r1247 r1415  
    11package schedframe.scheduling.manager.resources; 
    22 
    3 import java.util.ArrayList; 
    43import java.util.List; 
    54import java.util.Properties; 
    65 
    7 import schedframe.exceptions.ResourceException; 
    86import schedframe.resources.StandardResourceType; 
     7import schedframe.resources.computing.ComputingResource; 
    98import schedframe.resources.computing.Node; 
    10 import schedframe.resources.computing.ComputingResource; 
    119import schedframe.resources.computing.Processor; 
    1210import schedframe.scheduling.Scheduler; 
    … …  
    2220        @SuppressWarnings("unchecked") 
    2321        public List<Node> getNodes(){ 
    24                 try { 
    25                         return (List<Node>) getResourcesOfType(StandardResourceType.Node); 
    26                 } catch (ResourceException e) { 
    27                         return new ArrayList<Node>(); 
    28                 } 
     22                return (List<Node>) getResourcesOfType(StandardResourceType.Node); 
    2923        } 
    3024         
    3125        @SuppressWarnings("unchecked") 
    3226        public List<Processor> getProcessors(){ 
    33                 try { 
    34                         return (List<Processor>) getResourcesOfType(StandardResourceType.Processor); 
    35                 } catch (Exception e) { 
    36                         return new ArrayList<Processor>(); 
    37                 } 
     27                return (List<Processor>) getResourcesOfType(StandardResourceType.Processor); 
    3828        } 
    3929 

  • DCWoRMS/branches/coolemall/src/schedframe/scheduling/manager/resources/LocalResourceManager.java

    r1396 r1415  
    107107        } 
    108108 
    109         public List<? extends ComputingResource> getResourcesOfType(ResourceType type) throws ResourceException { 
     109        public List<? extends ComputingResource> getResourcesOfType(ResourceType type) { 
    110110                List<ComputingResource> resourcesOfType = new ArrayList<ComputingResource>(); 
    111111                for (ComputingResource resource : computingResources) { 
    … …  
    118118        } 
    119119 
    120         public List<? extends ComputingResource> getResourcesByTypeWithStatus(ResourceType type, ResourceStatus status) 
    121                         throws ResourceException { 
     120        public List<? extends ComputingResource> getResourcesByTypeWithStatus(ResourceType type, ResourceStatus status){ 
    122121 
    123122                List<ComputingResource> resourcesOfType = new ArrayList<ComputingResource>(); 
    … …  
    225224                List<ComputingResource> computingResources = null; 
    226225                if(areResourcesAchievable(StandardResourceType.Core)){ 
    227                         try { 
    228                                 computingResources = (List<ComputingResource>) getResourcesOfType(StandardResourceType.Core); 
    229                         } catch (ResourceException e) { 
    230                                 throw new RuntimeException("DCWorms internal error"); 
    231                         } 
     226 
     227                        computingResources = (List<ComputingResource>) getResourcesOfType(StandardResourceType.Core); 
     228 
    232229                        PEUnit peUnit = new ProcessingElements(computingResources); 
    233230                        peUnits = new ArrayList<ResourceUnit>(); 
    … …  
    236233 
    237234                else if(areResourcesAchievable(StandardResourceType.Processor)){ 
    238                         try { 
    239                                 computingResources = (List<ComputingResource>) getResourcesOfType(StandardResourceType.Processor); 
    240                         } catch (ResourceException e) { 
    241                                 throw new RuntimeException("DCWorms internal error"); 
    242                         } 
     235 
     236                        computingResources = (List<ComputingResource>) getResourcesOfType(StandardResourceType.Processor); 
     237 
    243238                        PEUnit peUnit = new ProcessingElements(computingResources); 
    244239                        peUnits = new ArrayList<ResourceUnit>(); 

  • DCWoRMS/branches/coolemall/src/schedframe/scheduling/manager/tasks/JobRegistryImpl.java

    r1396 r1415  
    5555                                        Set<String> visitedResource = task.getAllocatedResources().getLast().getResourceNames(); 
    5656                                        for(String res: visitedResource){ 
    57                                                 if(res.contains(context)){ 
     57                                                if(res.equals(context) || res.substring(0, res.lastIndexOf("/")).contains(context)){ 
    5858                                                        taskList.add(task); 
    5959                                                        break; 
    6060                                                } 
    6161                                        } 
    62                                         if(task.getSchedulerName().contains(context)) { 
     62                                        if(task.getSchedulerName().equals(context)) { 
    6363                                                taskList.add(task); 
    6464                                        } 

  • DCWoRMS/branches/coolemall/src/schedframe/scheduling/plugin/local/LocalSchedulingPlugin.java

    r1396 r1415  
    11package schedframe.scheduling.plugin.local; 
    22 
    3 import schedframe.events.scheduling.SchedulingEvent; 
    4 import schedframe.events.scheduling.SchedulingResponseType; 
    5 import schedframe.scheduling.manager.resources.ResourceManager; 
    6 import schedframe.scheduling.manager.tasks.JobRegistry; 
    7 import schedframe.scheduling.plugin.ModuleList; 
    83import schedframe.scheduling.plugin.SchedulingPlugin; 
    9 import schedframe.scheduling.queue.TaskQueueList; 
    104 
    115 
    126public interface LocalSchedulingPlugin extends SchedulingPlugin { 
    137 
    14         public SchedulingResponseType handleResourceAllocationViolation(SchedulingEvent event, 
    15                                         TaskQueueList queues,  
    16                                         JobRegistry jobRegistry,  
    17                                         ResourceManager resourceManager, ModuleList modules); 
    188 
    199} 

  • DCWoRMS/branches/coolemall/src/schedframe/scheduling/policy/global/GlobalManagementSystem.java

    r1385 r1415  
    7878                        return; 
    7979                } 
    80                  
    8180                registerWorkloadUnit(wu); 
    8281 

  • DCWoRMS/branches/coolemall/src/schedframe/scheduling/policy/local/LocalManagementSystem.java

    r1396 r1415  
    1919import schedframe.events.scheduling.StartTaskExecutionEvent; 
    2020import schedframe.events.scheduling.TaskFinishedEvent; 
     21import schedframe.events.scheduling.TaskPausedEvent; 
    2122import schedframe.events.scheduling.TaskRequestedTimeExpiredEvent; 
     23import schedframe.events.scheduling.TaskResumedEvent; 
    2224import schedframe.exceptions.ResourceException; 
    2325import schedframe.resources.StandardResourceType; 
    2426import schedframe.resources.computing.ComputingResource; 
    25 import schedframe.resources.computing.profiles.energy.EnergyEvent; 
    26 import schedframe.resources.computing.profiles.energy.EnergyEventType; 
     27import schedframe.resources.computing.profiles.energy.ResourceEvent; 
     28import schedframe.resources.computing.profiles.energy.ResourceEventType; 
    2729import schedframe.resources.units.PEUnit; 
    2830import schedframe.resources.units.ProcessingElements; 
    … …  
    163165                        String[] ids = (String[]) ev.get_data(); 
    164166                        execTask = jobRegistry.getTask(ids[0], ids[1]); 
    165                         taskPause(execTask); 
     167                        pauseTask(execTask); 
    166168                        if (pluginSupportsEvent(tag)) { 
    167                                 SchedulingEvent event = new SchedulingEvent(SchedulingEventType.TASK_PAUSED); 
     169                                SchedulingEvent event = new TaskPausedEvent(ids[0], ids[1]); 
    168170                                SchedulingPlanInterface<?> decision = schedulingPlugin.schedule(event, 
    169171                                                queues, jobRegistry, getResourceManager(), moduleList); 
    … …  
    176178                        String[] ids = (String[]) ev.get_data(); 
    177179                        execTask = jobRegistry.getTask(ids[0], ids[1]); 
    178                         taskResume(execTask, execTask.getAllocatedResources().getLast().getResourceUnits(), true); 
     180                        resumeTask(execTask, execTask.getAllocatedResources().getLast().getResourceUnits(), true); 
    179181                        if (pluginSupportsEvent(tag)) { 
    180                                 SchedulingEvent event = new StartTaskExecutionEvent(ids[0], ids[1]); 
     182                                SchedulingEvent event = new TaskResumedEvent(ids[0], ids[1]); 
    181183                                SchedulingPlanInterface<?> decision = schedulingPlugin.schedule(event, 
    182184                                                queues, jobRegistry, getResourceManager(), moduleList); 
    … …  
    189191                        Object[] data = (Object[]) ev.get_data(); 
    190192                        execTask = jobRegistry.getTask((String)data[0], (String)data[1]); 
    191                         double migrationTime = execTimeEstimationPlugin.estimateMigrationTime(new StartTaskExecutionEvent((String)data[0], (String)data[1]), execTask, execTask.getAllocatedResources().getLast().getResourceUnits(), (Map<ResourceUnitName, ResourceUnit>)data[2]); 
     193                        double migrationTime = execTimeEstimationPlugin.estimateMigrationTime(new StartTaskExecutionEvent((String)data[0],  
     194                                        (String)data[1]), execTask, execTask.getAllocatedResources().getLast().getResourceUnits(), (Map<ResourceUnitName, ResourceUnit>)data[2]); 
    192195                        scheduler.sendInternal(migrationTime, DCWormsTags.TASK_MOVE, data); 
    193196                } 
    … …  
    197200                        Object[] data = (Object[]) ev.get_data(); 
    198201                        execTask = jobRegistry.getTask((String)data[0], (String)data[1]); 
    199                         taskMove(execTask, (Map<ResourceUnitName, ResourceUnit>)data[2]); 
     202                        moveTask(execTask, (Map<ResourceUnitName, ResourceUnit>)data[2]); 
    200203                        if (pluginSupportsEvent(tag)) { 
    201204                                SchedulingEvent event = new StartTaskExecutionEvent((String)data[0], (String)data[1]); 
    … …  
    209212                case DCWormsTags.TASK_EXECUTION_CHANGED: 
    210213                        execTask = (ExecTask) ev.get_data(); 
    211                         updateTaskExecutionPhase(execTask, SchedulingEventType.RESOURCE_STATE_CHANGED); 
     214                        updateTaskExecutionPhase(execTask); 
    212215                        break; 
    213216 
    … …  
    231234                        } 
    232235                        break; 
    233                 } 
    234         } 
    235  
    236  
    237         public void taskPause(ExecTask execTask) { 
     236                default:                 
     237                         
     238                        break; 
     239                } 
     240        } 
     241 
     242 
     243        protected void pauseTask(ExecTask execTask) { 
    238244                if (execTask == null) { 
    239245                        return; 
    … …  
    246252                                getAllocationManager().freeResources(lastUsed, true); 
    247253                                 
    248                                 saveExecutionHistory(exec, exec.getCompletionPercentage(), exec.getEstimatedDuration()); 
     254                                saveExecutionHistory(exec, exec.getExecutionProfile().getCompletionPercentage(), exec.getEstimatedDuration()); 
    249255                                 
    250256                                ExecTaskFilter filter = new ExecTaskFilter(exec.getUniqueId(), -1); 
    … …  
    252258                                 
    253259                                PEUnit peUnit = (PEUnit)lastUsed.get(StandardResourceUnitName.PE); 
    254                                 updateComputingResources(peUnit, EnergyEventType.TASK_FINISHED, exec); 
     260                                updateComputingResources(peUnit, ResourceEventType.TASK_FINISHED, exec); 
    255261                        } catch (Exception e) { 
    256262                                // TODO Auto-generated catch block 
    … …  
    260266        } 
    261267         
    262         public void taskResume(ExecTask execTask, Map<ResourceUnitName, ResourceUnit> resources, boolean exclusive) { 
     268        protected void resumeTask(ExecTask execTask, Map<ResourceUnitName, ResourceUnit> resources, boolean exclusive) { 
    263269                if (execTask == null) { 
    264270                        return; 
    … …  
    278284                                         
    279285                                        PEUnit peUnit = (PEUnit)resources.get(StandardResourceUnitName.PE); 
    280                                         updateComputingResources(peUnit, EnergyEventType.TASK_STARTED, exec); 
     286                                        updateComputingResources(peUnit, ResourceEventType.TASK_STARTED, exec); 
    281287                                } 
    282288 
    … …  
    288294        } 
    289295         
    290         public void taskMove(ExecTask execTask, Map<ResourceUnitName, ResourceUnit> map) { 
    291                 taskPause(execTask); 
    292                 taskResume(execTask, map, false); 
     296        protected void moveTask(ExecTask execTask, Map<ResourceUnitName, ResourceUnit> map) { 
     297                pauseTask(execTask); 
     298                resumeTask(execTask, map, false); 
    293299        } 
    294300         
    … …  
    351357                 
    352358                PEUnit peUnit = (PEUnit)choosenResources.get(StandardResourceUnitName.PE); 
    353                 updateComputingResources(peUnit, EnergyEventType.RESOURCE_UTILIZATION_CHANGED, exec); 
     359                updateComputingResources(peUnit, ResourceEventType.UTILIZATION_CHANGED, exec); 
    354360                 
    355361 
    … …  
    377383 
    378384                int phaseDuration = Double.valueOf(execTimeEstimationPlugin.execTimeEstimation(new SchedulingEvent(SchedulingEventType.START_TASK_EXECUTION),  
    379                                 execTask, resources, exec.getCompletionPercentage())).intValue(); 
    380  
    381                 saveExecutionHistory(exec, exec.getCompletionPercentage(), phaseDuration); 
     385                                execTask, resources, exec.getExecutionProfile().getCompletionPercentage())).intValue(); 
     386 
     387                saveExecutionHistory(exec, exec.getExecutionProfile().getCompletionPercentage(), phaseDuration); 
    382388                if(exec.getExecutionProfile().isLast()){ 
    383389                        scheduler.sendInternal(phaseDuration, DCWormsTags.TASK_EXECUTION_FINISHED, execTask);; 
    … …  
    387393                 
    388394                PEUnit peUnit = (PEUnit)resources.get(StandardResourceUnitName.PE); 
    389                 updateComputingResources(peUnit, EnergyEventType.TASK_STARTED, exec); 
     395                updateComputingResources(peUnit, ResourceEventType.TASK_STARTED, exec); 
    390396                 
    391397        } 
    … …  
    429435                 
    430436                PEUnit peUnit = (PEUnit)lastUsed.get(StandardResourceUnitName.PE); 
    431                 updateComputingResources(peUnit, EnergyEventType.TASK_FINISHED, exec); 
     437                updateComputingResources(peUnit, ResourceEventType.TASK_FINISHED, exec); 
    432438                 
    433439                log.debug(execTask.getJobId() + "_" + execTask.getId() + " finished execution on " + new DateTime()); 
    434440                log.info(DCWormsConstants.USAGE_MEASURE_NAME + ": " + calculateTotalLoad()); 
    435441                 
    436                 updateComputingResources(peUnit, EnergyEventType.RESOURCE_UTILIZATION_CHANGED, exec); 
     442                updateComputingResources(peUnit, ResourceEventType.UTILIZATION_CHANGED, exec); 
    437443        } 
    438444         
    … …  
    452458                        //System.out.println("--- upadteProgressX: " + Sim_system.sim_clock() ); 
    453459                        //System.out.println("taskId: " + exec.getId() + "; completion percentage: " + exec.getCompletionPercentage() + "; timespan: " + timeSpan + "; estimatedDuration: " +  execHistItem.getCompletionPercentage()); 
    454                         exec.setCompletionPercentage(exec.getCompletionPercentage() + 100 * (timeSpan / (execHistItem.getEstimatedDuration()) * (1.0 - execHistItem.getCompletionPercentage()/100.0))); 
     460                        exec.getExecutionProfile().setCompletionPercentage(exec.getExecutionProfile().getCompletionPercentage() + 100 * (timeSpan / (execHistItem.getEstimatedDuration()) * (1.0 - execHistItem.getCompletionPercentage()/100.0))); 
     461                        exec.setTotalCompletionPercentage(exec.getTotalCompletionPercentage() + 100 * (timeSpan / execHistItem.getEstimatedDuration()) * exec.getExecutionProfile().getCurrentResourceConsumption().getLenght() / exec.getExecutionProfile().getLength()); 
    455462                        //System.out.println("newProgress: " + exec.getCompletionPercentage()  );        
    456463 
    … …  
    458465        } 
    459466         
    460         private void updateComputingResources(PEUnit peUnit, EnergyEventType eventType, Object obj){ 
     467        private void updateComputingResources(PEUnit peUnit, ResourceEventType eventType, Object obj){ 
    461468                if(peUnit instanceof ProcessingElements){ 
    462469                        ProcessingElements pes = (ProcessingElements) peUnit; 
    463470                        for (ComputingResource resource : pes) { 
    464                                 resource.handleEvent(new EnergyEvent(eventType, obj, scheduler.getFullName())); 
     471                                resource.handleEvent(new ResourceEvent(eventType, obj, scheduler.getFullName())); 
    465472                                //DataCenterWorkloadSimulator.getEventManager().sendToResources(resource.getType(), 0, new EnergyEvent(eventType, obj)); 
    466473                        } 
    … …  
    480487                                return; 
    481488                        } 
    482                         resource.handleEvent(new EnergyEvent(eventType, obj, scheduler.getFullName())); 
     489                        resource.handleEvent(new ResourceEvent(eventType, obj, scheduler.getFullName())); 
    483490                } 
    484491        } 
    … …  
    492499 
    493500                        int phaseDuration = Double.valueOf(execTimeEstimationPlugin.execTimeEstimation(new SchedulingEvent(SchedulingEventType.RESOURCE_STATE_CHANGED),  
    494                                         execTask, choosenResources, exec.getCompletionPercentage())).intValue(); 
     501                                        execTask, choosenResources, exec.getExecutionProfile().getCompletionPercentage())).intValue(); 
    495502 
    496503                        ExecutionHistoryItem execHistItem = exec.getExecutionHistory().getLast(); 
    497                         double lastTimeStamp = execHistItem.getTimeStamp().getMillis()/1000; 
    498                         if(DoubleMath.subtract((lastTimeStamp + execHistItem.getEstimatedDuration()), (new DateTime().getMillis()/1000 + phaseDuration)) == 0.0){ 
     504                        double lastTimeStamp = execHistItem.getTimeStamp().getMillis() / 1000; 
     505                        if(DoubleMath.subtract((lastTimeStamp + execHistItem.getEstimatedDuration()), (new DateTime().getMillis() / 1000 + phaseDuration)) == 0.0){ 
    499506                                continue; 
    500507                        } 
    … …  
    504511                        //System.out.println("completionPercantage: " + exec.getCompletionPercentage() + "; basic duration: " +exec.getResourceConsumptionProfile().getCurrentResourceConsumption().getDuration() +   "; phaseDuration: " +  phaseDuration); 
    505512 
    506                         saveExecutionHistory(exec, exec.getCompletionPercentage(), phaseDuration); 
     513                        saveExecutionHistory(exec, exec.getExecutionProfile().getCompletionPercentage(), phaseDuration); 
    507514                         
    508515                        if(exec.getExecutionProfile().isLast()){ 
    … …  
    522529        }        
    523530 
    524         protected void updateTaskExecutionPhase(ExecTask execTask, SchedulingEventType schedEvType) { 
     531        protected void updateTaskExecutionPhase(ExecTask execTask) { 
    525532 
    526533                if (execTask.getStatus() == DCWormsTags.INEXEC) { 
    … …  
    535542                        Map<ResourceUnitName, ResourceUnit> choosenResources = exec.getAllocatedResources().getLast().getResourceUnits(); 
    536543 
    537                         int phaseDuration = Double.valueOf(execTimeEstimationPlugin.execTimeEstimation(new SchedulingEvent(schedEvType),  
    538                                         execTask, choosenResources, exec.getCompletionPercentage())).intValue(); 
    539                          
    540                         saveExecutionHistory(exec, exec.getCompletionPercentage(), phaseDuration); 
     544                        int phaseDuration = Double.valueOf(execTimeEstimationPlugin.execTimeEstimation(new SchedulingEvent(SchedulingEventType.TASK_EXECUTION_CHANGED),  
     545                                        execTask, choosenResources, exec.getExecutionProfile().getCompletionPercentage())).intValue(); 
     546                         
     547                        saveExecutionHistory(exec, exec.getExecutionProfile().getCompletionPercentage(), phaseDuration); 
    541548                         
    542549                        if(exec.getExecutionProfile().isLast()){ 
    … …  
    547554                         
    548555                        PEUnit peUnit = (PEUnit)exec.getAllocatedResources().getLast().getResourceUnits().get(StandardResourceUnitName.PE); 
    549                         updateComputingResources(peUnit, EnergyEventType.RESOURCE_UTILIZATION_CHANGED, exec); 
     556                        updateComputingResources(peUnit, ResourceEventType.UTILIZATION_CHANGED, exec); 
    550557                } 
    551558        }        
    552559 
    553         public double calculateTotalLoad() { 
     560        protected double calculateTotalLoad() { 
    554561 
    555562                DCwormsAccumulator loadAcc = new DCwormsAccumulator(); 
    556                 try { 
    557                         for(ComputingResource compRes: getResourceManager().getResourcesOfType(StandardResourceType.Node)){ 
    558                                 loadAcc.add(compRes.getLoadInterface().getRecentUtilization().getValue());                               
    559                         } 
    560                 } catch (ResourceException e) { 
    561                         // TODO Auto-generated catch block 
    562                         e.printStackTrace(); 
    563                 } 
    564                  
     563 
     564                for(ComputingResource compRes: getResourceManager().getResourcesOfType(StandardResourceType.Node)){ 
     565                        loadAcc.add(compRes.getLoadInterface().getRecentUtilization().getValue());                               
     566                } 
     567 
    565568                return loadAcc.getMean(); 
    566569        } 
    … …  
    703706         
    704707        private void saveExecutionHistory(Executable exec, double completionPercentage, double estimatedDuration){ 
    705  
    706708                ExecutionHistoryItem execHistoryItem = new ExecutionHistoryItem(new DateTime()); 
    707709                execHistoryItem.setCompletionPercentage(completionPercentage); 
    … …  
    710712                execHistoryItem.setStatus(exec.getStatus()); 
    711713                exec.addExecHistory(execHistoryItem); 
    712                  
    713714        } 
    714715         

  • DCWoRMS/branches/coolemall/src/schedframe/scheduling/tasks/phases/ExecutionPhase.java

    r1207 r1415  
    1313import org.qcg.broker.schemas.resreqs.ResourceConsumptionType; 
    1414 
    15 public class ResourceConsumption { 
     15public class ExecutionPhase { 
    1616 
    1717        protected String id; 
    1818    protected Map<String, String> referenceHardware; 
    19     protected long duration; 
    20     protected List<PhaseBehaviour> phaseBehaviourList; 
     19    protected long originDuration; 
     20    protected long lenght; 
     21    protected List<PhaseSystemLoad> systemLoad; 
    2122     
    22     public ResourceConsumption(long duration, ComputingResourceBaseTypeItem item[]){ 
     23    public ExecutionPhase(long duration, ComputingResourceBaseTypeItem item[]){ 
    2324        this.id = null; 
    2425        this.referenceHardware = null; 
    25         this.duration = duration; 
    26         this.phaseBehaviourList = new ArrayList<PhaseBehaviour>(); 
     26        this.originDuration = duration; 
     27        this.systemLoad = new ArrayList<PhaseSystemLoad>(); 
    2728        for(ComputingResourceBaseTypeItem compResItem: item){ 
    2829                ComputingResourceParameterType hostParameter = compResItem.getHostParameter(); 
    29                 PhaseBehaviour pb = new PhaseBehaviour(hostParameter.getName().toString()); 
    30                 phaseBehaviourList.add(pb); 
     30                PhaseSystemLoad pb = new PhaseSystemLoad(hostParameter.getName().toString()); 
     31                systemLoad.add(pb); 
    3132        } 
     33        this.lenght = duration; 
    3234    } 
    3335     
    34     public ResourceConsumption(ResourceConsumptionType resConsumptionType){ 
     36    public ExecutionPhase(ResourceConsumptionType resConsumptionType){ 
    3537        this.id = resConsumptionType.getId(); 
    3638        this.referenceHardware = new HashMap<String, String>(); 
     39        this.originDuration = resConsumptionType.getDuration().toLong() / 1000; 
     40         
     41        double speed = 1; 
    3742        if(resConsumptionType.getReferenceHardware() != null){ 
    3843                for (int i = 0; i < resConsumptionType.getReferenceHardware().getReference().length; i++){ 
    3944                        StringParameterType spt = resConsumptionType.getReferenceHardware().getReference(i); 
    40                         referenceHardware.put(spt.getName(), spt.getContent()); 
     45                        this.referenceHardware.put(spt.getName(), spt.getContent()); 
     46                if(spt.getName().equals("cpu_maxfreq")){ 
     47                        speed = new Double(spt.getContent()); 
     48                } 
    4149                } 
    4250        } 
    43         this.duration = resConsumptionType.getDuration().toLong()/1000; 
    44         this.phaseBehaviourList = new ArrayList<PhaseBehaviour>(); 
     51        this.systemLoad = new ArrayList<PhaseSystemLoad>(); 
     52        int nrOfThreads = 1; 
    4553        for(PhaseBehaviourType pbt: resConsumptionType.getBehaviour()){ 
    46                 PhaseBehaviour pb = new PhaseBehaviour(pbt); 
    47                 phaseBehaviourList.add(pb); 
     54                PhaseSystemLoad pb = new PhaseSystemLoad(pbt); 
     55                this.systemLoad.add(pb); 
     56                if(pbt.getName().equals("PM_Threads")){ 
     57                        nrOfThreads = new Double(pbt.getParameterTypeChoice().getParameterTypeChoiceItem(0).getParameterValue().getContent()).intValue(); 
     58                } 
    4859        } 
     60        this.lenght = (long) (originDuration * nrOfThreads * speed); 
    4961    } 
    5062     
    … …  
    6274 
    6375        public long getDuration() { 
    64                 return duration; 
     76                return originDuration; 
    6577        } 
    6678 
    67         public List<PhaseBehaviour> getBehaviourList() { 
    68                 return phaseBehaviourList; 
     79        public List<PhaseSystemLoad> getSystemLoad() { 
     80                return systemLoad; 
     81        } 
     82 
     83        public long getLenght() { 
     84                return lenght; 
    6985        } 
    7086 

  • DCWoRMS/branches/coolemall/src/schedframe/scheduling/tasks/phases/ExecutionProfile.java

    r1362 r1415  
    55public class ExecutionProfile { 
    66         
    7         protected LinkedList<ResourceConsumption> resourceConsumptionList; 
     7        protected LinkedList<ExecutionPhase> resourceConsumptionList; 
    88        protected long usefulWork; 
     9        protected double completionPercentage; 
    910        private int currentPhase; 
     11         
    1012 
    11         public ExecutionProfile(LinkedList<ResourceConsumption> resourceConsumptionList) { 
     13        public ExecutionProfile(LinkedList<ExecutionPhase> resourceConsumptionList) { 
    1214                this.resourceConsumptionList = resourceConsumptionList; 
     15                this.completionPercentage = 0; 
    1316                this.currentPhase = 0; 
    1417        } 
    1518         
    16         public LinkedList<ResourceConsumption> getResourceConsumptionList(){ 
     19        public LinkedList<ExecutionPhase> getResourceConsumptionList(){ 
    1720                return resourceConsumptionList; 
    1821        } 
    1922         
    20         public ResourceConsumption getCurrentResourceConsumption(){ 
     23        public ExecutionPhase getCurrentResourceConsumption(){ 
    2124                return resourceConsumptionList.get(currentPhase); 
    2225        } 
    … …  
    4447                return false; 
    4548        } 
     49 
     50        public double getCompletionPercentage() { 
     51                return completionPercentage; 
     52        } 
     53 
     54        public void setCompletionPercentage(double completionPercentage) { 
     55                this.completionPercentage = completionPercentage; 
     56        } 
     57         
     58        public long getLength() { 
     59                long length = 0; 
     60                for(ExecutionPhase execPhase: resourceConsumptionList){ 
     61                        length = length + execPhase.getLenght(); 
     62                } 
     63                return length; 
     64        } 
    4665} 

  • DCWoRMS/branches/coolemall/src/schedframe/scheduling/tasks/phases/PhaseSystemLoad.java

    r883 r1415  
    33import org.qcg.broker.schemas.resreqs.PhaseBehaviourType; 
    44 
    5 public class PhaseBehaviour { 
     5public class PhaseSystemLoad { 
    66         
    77        protected String resName; 
    88        protected double utilization; 
    99         
    10         PhaseBehaviour(String resName, double utilization) { 
     10        PhaseSystemLoad(String resName, double utilization) { 
    1111                this.resName = resName; 
    1212                this.utilization = utilization; 
    1313        } 
    1414         
    15         PhaseBehaviour(String resName) { 
     15        PhaseSystemLoad(String resName) { 
    1616                this.resName = resName; 
    1717                this.utilization = 100; 
    1818        } 
    1919         
    20         PhaseBehaviour(PhaseBehaviourType pbt) { 
     20        PhaseSystemLoad(PhaseBehaviourType pbt) { 
    2121                this.resName = pbt.getName(); 
    2222                this.utilization = pbt.getParameterTypeChoice().getParameterTypeChoiceItem(0).getParameterValue().getContent(); 

  • DCWoRMS/branches/coolemall/src/simulator/DataCenterWorkloadSimulator.java

    r1346 r1415  
    271271 
    272272 
    273                 boolean traceFlag = true; // means: trace GridSim events/activities 
    274                 String[] excludeFromFile = { "" }, excludeFromProcessing = { "" }; 
    275                  
    276                 GridSimWrapper.init(numUser, calendar, traceFlag, excludeFromFile, 
    277                                 excludeFromProcessing, null); 
     273                boolean traceFlag = false; // means: trace GridSim events/activities 
     274 
     275                GridSimWrapper.init(numUser, calendar, traceFlag); 
    278276                DateTimeUtilsExt.initVirtualTimeAccess(calendar); 
    279277 

  • DCWoRMS/branches/coolemall/src/simulator/stats/DCwormsMetricsCalculator.java

    r1396 r1415  
    1414        public List<MetricsStats> calulateMetrics(){ 
    1515                List<MetricsStats> metrics = new ArrayList<MetricsStats>(); 
    16                 /*for(String resourceTypeName: metricsData.keySet()){ 
    17                         MetricsStats metric = new MetricsStats(resourceTypeName, "energyUsage", metricsData.get(resourceTypeName).getMax()); 
    18                         metrics.add(metric);} 
    19                 }*/ 
     16 
     17                /* 
    2018                metrics.add(calculateITComputingEnergyConsumption()); 
    2119                metrics.add(calculateITEnergyConsumption()); 
    … …  
    3432                metrics.add(calculateUsefulWork()); 
    3533                metrics.add(calculateProductivity()); 
    36  
     34                 */ 
     35                 
    3736                return metrics; 
    3837        } 
Note: See TracChangeset for help on using the changeset viewer.