source: DCWoRMS/branches/coolemall/src/simulator/stats/implementation/TaskStats.java @ 1570

package simulator.stats.implementation;


import gridsim.dcworms.DCWormsTags;

import java.util.ArrayList;
import java.util.Collections;
import java.util.Comparator;
import java.util.HashSet;
import java.util.Iterator;
import java.util.List;
import java.util.Set;
import java.util.TreeSet;

import schedframe.resources.computing.ComputingResource;
import schedframe.resources.computing.Core;
import schedframe.resources.computing.Node;
import schedframe.resources.computing.Processor;
import schedframe.scheduling.ExecutionHistoryItem;
import simulator.stats.implementation.out.StatsSerializer;
import dcworms.schedframe.scheduling.Executable;


/**
 * 
 * @author Marcin Krystek
 * 
 */
public class TaskStats implements StatsInterface {
        protected Set<ComputingResource> processingElements;
        protected double reservationStartDate;
        protected double reservationFinishDate;

        protected Executable task;
        protected long startSimulationTimeSek;
        
        private String headers[] = { "JobID", "TaskID", "UserDN", "SchedName", "CpuCnt",
                        "ExecStartDate", "ExecFinishDate", "ExecEndDate", "GB_SubDate",
                        "LB_SubDate", "CompletionTime", "ExecStartTime",
                        "ExecutionTime", "ReadyTime", "StartTime", "FlowTime",
                        "WaitingTime", "GQ_WaitingTime", "Lateness", "Tardiness",
                        "ReservStartDate", "ReservFinishDate", "HostNames", "ProcessorName", "Energy", "AppName",};

        public TaskStats(Executable task, long startSimulationTime) {
                this.task = task;
                this.startSimulationTimeSek = startSimulationTime / 1000;
        }

        public Object serialize(StatsSerializer serializer) {
                return serializer.visit(this);
        }

        public String getJobID() {
                return this.task.getJobId();
        }

        public String getTaskID() {
                return this.task.getId();
        }

        public String getUserDN() {
                return this.task.getUserDN();
        }

        public String getResName() {
                String resName = this.task.getSchedulerName();

                return resName;
        }

        public long getCpuCnt() {
                long cpuCnt = -1;
                try {
                        cpuCnt = Double.valueOf(task.getCpuCntRequest()).longValue();
                } catch (NoSuchFieldException e) {
                }

                return cpuCnt;
        }

        public double getExecStartDate() {
                return task.getExecStartTime();
        }

        public double getExecFinishDate() {
                return task.getFinishTime();
        }

        public double getExecEndDate() {
                double ret = -1;
                try {
                        ret = task.getExecutionEndTime().getMillis() / 1000;
                } catch (NoSuchFieldException e) {
                        ret = task.getFinishTime();
                }
                return ret;
        }

        public double getGB_SubDate() {
                return task.getSubmissionTimeToBroker().getMillis() / 1000;
        }

        public double getLB_SubDate() {
                return task.getSubmissionTime();
        }

        public double getCompletionTime() {
                return task.getFinishTime() - startSimulationTimeSek;
        }

        public double getExecutionTime() {
                double executionTime = 0;
                long previousTimestamp = 0;             
                int previousStatus = DCWormsTags.CREATED;
                for(ExecutionHistoryItem execHistItem: task.getExecutionHistory()){
                        if(previousStatus == DCWormsTags.INEXEC){
                                executionTime = executionTime  + (execHistItem.getTimeStamp()/1000 - previousTimestamp);
                        } 
                        previousTimestamp  = execHistItem.getTimeStamp()/1000;
                        previousStatus = execHistItem.getStatus();
                }
                return executionTime;
                //return task.getFinishTime() - task.getExecStartTime();
        }

        public double getExecStartTime() {
                return task.getExecStartTime() - startSimulationTimeSek;
        }

        public double getReadyTime() {
                double readyTime = 0;

                try {
                        readyTime = task.getExecutionStartTime().getMillis() / 1000
                                        - startSimulationTimeSek;
                } catch (Exception ex) {
                        readyTime = task.getSubmissionTimeToBroker().getMillis()/1000 - startSimulationTimeSek;
                }

                return readyTime;
        }

        public double getStartTime() {
                return task.getExecStartTime()
                                - task.getSubmissionTimeToBroker().getMillis() / 1000;
        }

        public double getFlowTime() {
                return getCompletionTime() - getReadyTime();
        }

        public double getWaitingTime() {
                return task.getWaitingTime();
        }

        public double getGQ_WaitingTime() {
                return task.getSubmissionTime()
                                - task.getSubmissionTimeToBroker().getMillis() / 1000;
        }

        public double getLateness() {
                double execEndDate = getExecEndDate();
                double lateness = 0;
                if (execEndDate != -1) {
                        lateness = task.getFinishTime() - execEndDate;
                }
                return lateness;
        }

        public double getTardiness() {
                return Math.max(getLateness(), 0.0);
        }

        public void setProcessors(Set<ComputingResource> value) {
                this.processingElements = value;
        }

        public void setReservationStartDate(double value) {
                this.reservationStartDate = value;
        }

        public void setReservationFinishDate(double value) {
                this.reservationFinishDate = value;
        }

        public Set<String> getProcessingElementsName() {
                Set<String> processingElementsNames = new TreeSet<String>();
                Iterator<ComputingResource> it = processingElements.iterator();
                while(it.hasNext()) {
                        ComputingResource compRes = it.next();
                        processingElementsNames.add(compRes.getFullName());
                }
                return processingElementsNames;
        }

        public Set<String> getHostName() {
                Set<String> hostNames = new TreeSet <String>();
                Iterator<ComputingResource> it = processingElements.iterator();
                while(it.hasNext()) {
                        ComputingResource compRes = it.next();
                        Node node = null;
                        if(compRes instanceof Core){
                                Core core =(Core) compRes;
                                node = (Node)core.getNode();
                        } else if(compRes instanceof Processor){
                                Processor proc = (Processor) compRes;
                                node = (Node)proc.getNode();
                        } else if(compRes instanceof Node){
                                node = (Node)compRes;
                        }
                        if(node != null)
                                hostNames.add(node.getFullName());
                }

                return hostNames;
        }
        
        public double getReservationStartDate() {
                return reservationStartDate;
        }

        public double getReservationFinishDate() {
                return reservationFinishDate;
        }
        
        public String getExecName() {
                String execName = null;
                if(task.getDescription().getExecution() != null) {
                        if(task.getDescription().getExecution().getStdin()!= null && task.getDescription().getExecution().getStdin().length > 0)
                                execName = task.getDescription().getExecution().getStdin()[0].getName();
                        else if(task.getDescription().getExecution().getExecutable() != null && task.getDescription().getExecution().getExecutable().getApplication() != null)
                                execName = task.getDescription().getExecution().getExecutable().getApplication().getName();
                }
                return execName;
        }

        public String[] getHeaders() {
                return headers;
        }

}