source: DCWoRMS/branches/coolemall/src/example/timeestimation/coolemall/CPUFreqScallingPhaseTimeEstimationPlugin.java @ 1299

package example.timeestimation.coolemall;

import java.util.Map;

import org.joda.time.DateTime;

import schedframe.events.scheduling.SchedulingEvent;
import schedframe.resources.computing.ComputingResource;
import schedframe.resources.computing.Core;
import schedframe.resources.computing.Processor;
import schedframe.resources.units.PEUnit;
import schedframe.resources.units.ProcessingElements;
import schedframe.resources.units.ResourceUnit;
import schedframe.resources.units.ResourceUnitName;
import schedframe.resources.units.StandardResourceUnitName;
import schedframe.scheduling.tasks.phases.ResourceConsumption;
import dcworms.schedframe.scheduling.ExecTask;
import dcworms.schedframe.scheduling.Executable;
import example.timeestimation.BaseTimeEstimationPlugin;

public class CPUFreqScallingPhaseTimeEstimationPlugin extends BaseTimeEstimationPlugin{

        
        public double execTimeEstimation(SchedulingEvent event, ExecTask task,
                        Map<ResourceUnitName, ResourceUnit> allocatedResources,
                        double completionPercentage) {
                
                Executable exec = (Executable) task;
                ResourceConsumption resConsumption = exec.getResourceConsumptionProfile().getCurrentResourceConsumption();
                String taskFreqString = task.getCurrentResourceConsumption().getReferenceHardware().get("cpu_maxfreq");
                double taskFreq = Double.valueOf(taskFreqString);
                
                PEUnit peUnit = (PEUnit) allocatedResources.get(StandardResourceUnitName.PE);
                double currentFrequency = 0;
                
                if(peUnit instanceof ProcessingElements){
                        ProcessingElements pes = (ProcessingElements) peUnit;
                        for (ComputingResource compResource : pes) {
                                if(compResource instanceof Core) {
                                        Core core = (Core) compResource;
                                        currentFrequency = core.getProcessor().getPowerInterface().getPState().getFrequency();
                                        break;
                                } else if (compResource instanceof Processor) {
                                        Processor processor = (Processor) compResource;
                                        currentFrequency = processor.getPowerInterface().getPState().getFrequency();
                                        break;
                                }
                        }
                }
                else 
                        currentFrequency = taskFreq;

                double execTime = (1 - completionPercentage/100) * resConsumption.getDuration() * (taskFreq / currentFrequency);

                // if the result is very close to 0, but less then one millisecond then round this result to 0.001
                if (Double.compare(execTime, 0.001) < 0) {
                        execTime = 0.001;
                }

                // time is measured in integer units, so get the nearest execTime int value.
                execTime = Math.round(execTime);
                return execTime;
        }

}