source: xssim/branches/tpiontek/src/example/timeestimation/ExecTimeEstimationPlugin.java @ 250

package example.timeestimation;

import gssim.schedframe.scheduling.ExecTaskInterface;

import java.util.Map;
import java.util.Properties;

import schedframe.resources.units.ResourceUnit;
import schedframe.scheduling.events.SchedulingEvent;
import schedframe.scheduling.plugin.SchedulingPluginConfiguration;
import schedframe.scheduling.utils.ResourceParameterName;
import test.rewolucja.energy.profile.PState;
import test.rewolucja.energy.profile.PStateType;
import test.rewolucja.resources.ProcessingElements;
import test.rewolucja.resources.physical.implementation.Processor;


/**
 * 
 * @author Marcin Krystek
 *
 */
public class ExecTimeEstimationPlugin implements schedframe.scheduling.plugin.estimation.ExecTimeEstimationPlugin{

        /*
         * This method should return an estimation of time required to execute the task.
         * Requested calculation should be done based on the resources allocated for the task,
         * task description and task remaining length (in instructions).
         * 
         * Example implementation calculate the estimation based on cpu processing power.
         * There is also a simple assumption, that cpu processing power is a linear function
         * of number of allocated cpus and their speed.
         */
        public double execTimeEstimation(SchedulingEvent event,
                        Map<ResourceParameterName, ResourceUnit> allocatedResources,
                        ExecTaskInterface task, double completionPercentage) {
                
                // collect all information necessary to do the calculation
                ProcessingElements pes = (ProcessingElements) allocatedResources.get(ResourceParameterName.PROCESSINGELEMENTS);

                // obtain single pe speed
                int speed = pes.getSpeed();
                
                // number of used pe  
                int cnt = pes.getUsedAmount();

                double remainingLength =  task.getLength() * (1- completionPercentage);
                // do the calculation
                
                
                int type = Integer.parseInt( task.getJobId()) % 4;
                
                double factor = 1;
                if( type == 0 && ((Processor)pes.get(0)).getComputingNode().getCategory().getName().equals("A"))
                {
                        factor = 0.6;
                }
                
                double execTime = (remainingLength / (cnt * (double)speed * factor / 1000));
                

                // 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.ceil(execTime);
                
                return execTime;
        }

        public SchedulingPluginConfiguration getConfiguration() {
                // This plugin in not expected to have any specific configuration.
                return null;
        }

        public String getName() {
                return "ExampleTimeEstimationPlugin";
        }

        public void init(Properties properties) {
        }

}