Context Navigation

GSSimStatistics.java @ 5

Revision 5, 62.6 KB checked in by wojtekp, 14 years ago (diff)

Property svn:mime-type set to `text/plain`

Rev	Line
[5]	1	package simulator.stats.implementation;
	2
	3	import eduni.simjava.Sim_stat;
	4	import gridsim.gssim.GssimConstants;
	5	import gridsim.gssim.ResourceHistoryItem;
	6	import gridsim.gssim.ResourceUnitsManagerImpl;
	7	import gridsim.gssim.SubmittedTask;
	8	import gridsim.gssim.network.ExtendedGridSimTags;
	9	import gridsim.gssim.network.flow.reservation.GSSIMFlowLink;
	10	import gridsim.gssim.network.sim.NetworkGridBroker;
	11	import gridsim.gssim.policy.ARAllocationPolicy;
	12	import gridsim.gssim.policy.AbstractAllocationPolicy;
	13	import gridsim.gssim.resource.AbstractComputingResource;
	14	import gridsim.gssim.resource.ResourceProcessors;
	15	import gssim.schedframe.scheduling.AbstractExecutable;
	16	import gssim.schedframe.scheduling.plugin.grid.network.manager.NetworkData;
	17	import gssim.schedframe.scheduling.plugin.grid.network.manager.NetworkReservationObject;
	18	import gssim.schedframe.scheduling.plugin.grid.network.manager.TaskInputFile;
	19	import gssim.schedframe.scheduling.plugin.grid.network.manager.Topology;
	20
	21	import java.awt.Color;
	22	import java.awt.Paint;
	23	import java.io.File;
	24	import java.io.FileOutputStream;
	25	import java.io.IOException;
	26	import java.io.PrintStream;
	27	import java.text.NumberFormat;
	28	import java.util.ArrayList;
	29	import java.util.Calendar;
	30	import java.util.Collections;
	31	import java.util.Comparator;
	32	import java.util.Date;
	33	import java.util.HashMap;
	34	import java.util.Iterator;
	35	import java.util.List;
	36	import java.util.Map;
	37	import java.util.SortedMap;
	38	import java.util.TreeMap;
	39
	40	import org.apache.commons.logging.Log;
	41	import org.apache.commons.logging.LogFactory;
	42	import org.jfree.chart.ChartFactory;
	43	import org.jfree.chart.ChartRenderingInfo;
	44	import org.jfree.chart.ChartUtilities;
	45	import org.jfree.chart.JFreeChart;
	46	import org.jfree.chart.axis.AxisLocation;
	47	import org.jfree.chart.axis.DateAxis;
	48	import org.jfree.chart.axis.NumberAxis;
	49	import org.jfree.chart.encoders.ImageFormat;
	50	import org.jfree.chart.labels.CategoryItemLabelGenerator;
	51	import org.jfree.chart.labels.ItemLabelAnchor;
	52	import org.jfree.chart.labels.ItemLabelPosition;
	53	import org.jfree.chart.labels.StandardCategoryItemLabelGenerator;
	54	import org.jfree.chart.plot.CategoryPlot;
	55	import org.jfree.chart.plot.CombinedDomainXYPlot;
	56	import org.jfree.chart.plot.PlotOrientation;
	57	import org.jfree.chart.plot.XYPlot;
	58	import org.jfree.chart.renderer.category.CategoryItemRenderer;
	59	import org.jfree.chart.renderer.category.GanttRenderer;
	60	import org.jfree.chart.renderer.xy.XYStepAreaRenderer;
	61	import org.jfree.chart.title.TextTitle;
	62	import org.jfree.chart.title.Title;
	63	import org.jfree.data.gantt.TaskSeries;
	64	import org.jfree.data.gantt.TaskSeriesCollection;
	65	import org.jfree.data.time.FixedMillisecond;
	66	import org.jfree.data.xy.XYDataset;
	67	import org.jfree.data.xy.XYSeries;
	68	import org.jfree.data.xy.XYSeriesCollection;
	69	import org.jfree.ui.TextAnchor;
	70	import org.joda.time.DateTime;
	71	import org.joda.time.DateTimeUtilsExt;
	72
	73	import schedframe.resources.profile.PowerUsage;
	74	import schedframe.resources.units.Processor;
	75	import schedframe.resources.units.Processors;
	76	import schedframe.resources.units.ResourceUnit;
	77	import schedframe.scheduling.Job;
	78	import schedframe.scheduling.JobInterface;
	79	import schedframe.scheduling.Reservation;
	80	import schedframe.scheduling.TimeResourceAllocation;
	81	import schedframe.scheduling.utils.ResourceParameterName;
	82	import simulator.AbstractGridBroker;
	83	import simulator.ConfigurationOptions;
	84	import simulator.GenericUser;
	85	import simulator.GridSchedulingSimulator;
	86	import simulator.stats.GSSAccumulator;
	87	import simulator.stats.SimulationStatistics;
	88	import simulator.stats.implementation.out.AbstractStringSerializer;
	89	import simulator.stats.implementation.out.FormatedStringSerializer;
	90	import simulator.stats.implementation.out.StringSerializer;
	91	import csiro.mit.utils.jfreechart.timetablechart.TimetableChartFactory;
	92	import csiro.mit.utils.jfreechart.timetablechart.data.Timetable;
	93	import csiro.mit.utils.jfreechart.timetablechart.data.TimetableEventGroup;
	94	import csiro.mit.utils.jfreechart.timetablechart.data.TimetableEventSource;
	95	import csiro.mit.utils.jfreechart.timetablechart.renderer.TimetableRenderer;
	96
	97	public class GSSimStatistics implements SimulationStatistics {
	98
	99	private Log log = LogFactory.getLog(GSSimStatistics.class);
	100
	101	protected static float ALPHA = 0.5f;
	102	protected static int GANTT_WIDTH = 1200;
	103
	104	protected static final int BITS = 8;
	105	protected static final int MILLI_SEC = 1000;
	106
	107
	108	protected static final String RAW_RESOURCE_STATISTICS_OUTPUT_FILE_NAME = "Raw_Resources.txt";
	109	protected static final String RAW_TASKS_STATISTICS_OUTPUT_FILE_NAME = "Raw_Tasks.txt";
	110	protected static final String ACCUMULATED_RESOURCES_STATISTICS_OUTPUT_FILE_NAME = "Accumulated_Resources.txt";
	111	protected static final String JOBS_STATISTICS_OUTPUT_FILE_NAME = "Jobs.txt";
	112	protected static final String GRIDLETS_STATISTICS_OUTPUT_FILE_NAME = "Gridlets.txt";
	113	protected static final String SIMULATION_STATISTICS_OUTPUT_FILE_NAME = "Simulation.txt";
	114	protected static final String NETWORK_SIMULATION_STATISTICS_OUTPUT_FILE_NAME = "Network.txt";
	115	protected static final String RESOURCE_LOAD_STATISTICS_OUTPUT_FILE_NAME = "Resource_Load.txt";
	116	protected static final String ENERGYUSAGE_STATISTICS_OUTPUT_FILE_NAME = "Energy.txt";
	117
	118	protected static final String DIAGRAMS_FILE_NAME_PREFIX = "Gantt_";
	119	protected static final String STATS_FILE_NAME_PREFIX = "Stats_";
	120
	121	protected static final String TASK_SEPARATOR = ";";
	122	protected static final String JOB_HEADER_SEPARATOR = ";";
	123	protected static final String JOB_SEPARATOR = ";";
	124	protected static final String RESOURCE_SEPARATOR = ";";
	125	protected static final String NETWORK_SEPARATOR = ";";
	126
	127	protected String outputFolderName;
	128
	129	protected String simulationIdentifier;
	130	protected ConfigurationOptions configuration;
	131	protected GenericUser users;
	132	protected AbstractGridBroker brokerInterface;
	133	protected AbstractComputingResource gridResources[];
	134	protected List<Reservation> reservations;
	135	protected HashMap<String, Reservation> reservationsMap;
	136	// protected HashMap<String, String> task_processorMap;
	137	protected HashMap<String, List<String>> task_processorsMap;
	138	protected List<NetworkData> receivedNetData;
	139	protected Topology topology;
	140
	141	protected long startSimulationTime;
	142	protected long endSimulationTime;
	143
	144	/* protected GSSAccumulator meanTotalLoad;
	145	protected GSSAccumulator meanReservationLoad;
	146	protected GSSAccumulator meanQueueLength;
	147	protected GSSAccumulator meanEnergyUsage;
	148
	149	protected GSSAccumulator meanTaskStartTime;
	150	protected GSSAccumulator meanTaskCompletionTime;
	151	protected GSSAccumulator meanTaskExecutionTime;
	152	protected GSSAccumulator meanTaskWaitingTime;
	153	protected GSSAccumulator meanTaskFlowTime;
	154	protected GSSAccumulator lateness;
	155	protected GSSAccumulator tardiness;
	156	protected GSSAccumulator delayedTasks;
	157	protected GSSAccumulator failedRequests;
	158	protected GSSAccumulator makespan;
	159	*/
	160	protected GSSAccumulatorsStats accStats;
	161
	162	protected Map<String, GSSAccumulator> statsData;
	163
	164	protected int numOfdelayedTasks = 0;
	165	protected int numOfNotExecutedTasks = 0;
	166	protected double maxCj = 0;
	167
	168	protected boolean allTasksFinished;
	169
	170	protected boolean generateDiagrams = true;
	171
	172	protected List<XYDataset> ganttDiagramResources;
	173	protected Timetable ganttDiagramProcessorsTimetable;
	174	protected TaskSeriesCollection ganttDiagramTaskSeriesCollection;
	175	protected TaskSeriesCollection ganttDiagramWaitingTimeSeriesCollection;
	176	protected TaskSeriesCollection ganttDiagramReservationSeriesCollection;
	177	protected List<XYDataset> ganttDiagramResourcesEnergy;
	178
	179	protected Map<String, TimetableEventSource> processorsGanttMap;
	180	protected Map<String, TimetableEventGroup> taskGanttMap;
	181
	182	protected AbstractStringSerializer serializer;
	183
	184	public GSSimStatistics(String simulationIdentifier,
	185	ConfigurationOptions co, GenericUser users,
	186	AbstractGridBroker brokerInterface,
	187	AbstractComputingResource gridResources[], Topology topology) {
	188	this.simulationIdentifier = simulationIdentifier;
	189	this.configuration = co;
	190	this.users = users;
	191	this.brokerInterface = brokerInterface;
	192	this.gridResources = gridResources;
	193	this.topology = topology;
	194
	195	if (this.configuration.formatstatisticsoutput)
	196	this.serializer = new FormatedStringSerializer();
	197	else
	198	this.serializer = new StringSerializer();
	199
	200	this.serializer.setFieldSeparator(TASK_SEPARATOR);
	201
	202	init();
	203	}
	204
	205	public GSSimStatistics(String simulationIdentifier,
	206	ConfigurationOptions co, GenericUser users,
	207	AbstractGridBroker brokerInterface,
	208	AbstractComputingResource gridResources[], Topology topology,
	209	String outputFolderName) {
	210	this.simulationIdentifier = simulationIdentifier;
	211	this.configuration = co;
	212	this.users = users;
	213	this.brokerInterface = brokerInterface;
	214	this.gridResources = gridResources;
	215	this.topology = topology;
	216	this.outputFolderName = outputFolderName;
	217
	218	if (this.configuration.formatstatisticsoutput)
	219	this.serializer = new FormatedStringSerializer();
	220	else
	221	this.serializer = new StringSerializer();
	222
	223	this.serializer
	224	.setDefaultNumberFormat(GridSchedulingSimulator.DFAULT_NUMBER_FORMAT);
	225
	226	init();
	227	}
	228
	229	public void generateStatistics() {
	230
	231	this.startSimulationTime = DateTimeUtilsExt.getOffsetTime()
	232	.getTimeInMillis();
	233
	234	this.endSimulationTime = DateTimeUtilsExt.currentTimeMillis();
	235
	236	long s = 0;
	237	long e = 0;
	238	// prepareStatisticsDirectory();
	239	log.info("gatherResourceStatistics");
	240	s = System.currentTimeMillis();
	241	gatherResourceStatistics();
	242	e = System.currentTimeMillis();
	243	log.info("time in sec: " + ((e - s) / 1000));
	244
	245	log.info("gatherNetworkStatistics");
	246	s = System.currentTimeMillis();
	247	gatherNetworkStatistics();
	248	e = System.currentTimeMillis();
	249	log.info("time in sec: " + ((e - s) / 1000));
	250
	251	log.info("gatherTaskStatistics");
	252	s = System.currentTimeMillis();
	253	gatherTaskStatistics();
	254	e = System.currentTimeMillis();
	255	log.info("time in sec: " + ((e - s) / 1000));
	256
	257	log.info("saveSimulationStatistics");
	258	s = System.currentTimeMillis();
	259	saveSimulationStatistics();
	260	e = System.currentTimeMillis();
	261	log.info("time in sec: " + ((e - s) / 1000));
	262	}
	263
	264	/*
	265	* public void prepareStatisticsDirectory(){
	266	*
	267	* String dirName = null; if (configuration.createScenario) { dirName =
	268	* configuration.outputFolder + configuration.statsOutputSubfolderNameCreate
	269	* + File.separator; } else { if(configuration.inputFolder != null){ dirName
	270	* = configuration.inputFolder; }else if(configuration.inputWorkloadFileName
	271	* != null){ dirName = new
	272	* File(configuration.inputWorkloadFileName).getParent(); }else{ dirName =
	273	* System.getProperty("user.dir"); } dirName += "/" +
	274	* configuration.statsOutputSubfolderNameRerad + File.separator; }
	275	* outputFolderName = dirName;
	276	*
	277	* File folder = new File(dirName); File fileList[] = folder.listFiles();
	278	* for(int i = 0; i < fileList.length; i++){ File tmpFile = fileList[i];
	279	* String name = tmpFile.getName();
	280	* if(name.startsWith(simulationIdentifier)) tmpFile.delete();
	281	* if(name.length() > 4){ String subName = name.substring(0, 5);
	282	* if(subName.compareTo("Gantt") == 0 \|\| subName.compareTo("Stats") == 0){
	283	* tmpFile.delete(); } } } }
	284	*/
	285
	286	public String getOutputFolderName() {
	287	return outputFolderName;
	288	}
	289
	290	private void init() {
	291
	292	reservations = new ArrayList<Reservation>();
	293	reservationsMap = new HashMap<String, Reservation>();
	294	// task_processorMap = new HashMap<String, String>();
	295	task_processorsMap = new HashMap<String, List<String>>();
	296	receivedNetData = new ArrayList<NetworkData>();
	297	/* meanTotalLoad = new GSSAccumulator();
	298	meanReservationLoad = new GSSAccumulator();
	299	meanQueueLength = new GSSAccumulator();
	300	meanEnergyUsage = new GSSAccumulator();
	301
	302	meanTaskStartTime = new GSSAccumulator();
	303	meanTaskCompletionTime = new GSSAccumulator();
	304	meanTaskExecutionTime = new GSSAccumulator();
	305	meanTaskWaitingTime = new GSSAccumulator();
	306	meanTaskFlowTime = new GSSAccumulator();
	307	lateness = new GSSAccumulator();
	308	tardiness = new GSSAccumulator();
	309	delayedTasks = new GSSAccumulator();
	310	failedRequests = new GSSAccumulator();
	311	makespan = new GSSAccumulator();
	312	*/
	313	accStats = new GSSAccumulatorsStats();
	314	statsData = new HashMap<String, GSSAccumulator>();
	315
	316	processorsGanttMap = new HashMap<String, TimetableEventSource>();
	317	taskGanttMap = new HashMap<String, TimetableEventGroup>();
	318	}
	319
	320	public void saveSimulationStatistics() {
	321	PrintStream simulationStatsFile = null;
	322	if (configuration.createsimulationstatistics) {
	323	try {
	324	File file = new File(outputFolderName + STATS_FILE_NAME_PREFIX
	325	+ simulationIdentifier + "_"
	326	+ SIMULATION_STATISTICS_OUTPUT_FILE_NAME);
	327	simulationStatsFile = new PrintStream(
	328	new FileOutputStream(file));
	329	} catch (IOException e) {
	330	e.printStackTrace();
	331	}
	332	}
	333	if (simulationStatsFile != null) {
	334
	335	Object txt = accStats.serialize(this.serializer);
	336	simulationStatsFile.println(txt);
	337
	338	}
	339
	340	if (simulationStatsFile != null) {
	341	simulationStatsFile.close();
	342	}
	343
	344	}
	345
	346
	347	/*********** RESOURCE STATISTICS SECTION ************/
	348	public void gatherResourceStatistics() {
	349
	350	PrintStream resourceStatsFile = null;
	351	try {
	352	File file = new File(outputFolderName + STATS_FILE_NAME_PREFIX
	353	+ simulationIdentifier + "_"
	354	+ RAW_RESOURCE_STATISTICS_OUTPUT_FILE_NAME);
	355	resourceStatsFile = new PrintStream(new FileOutputStream(file));
	356	} catch (IOException e) {
	357	resourceStatsFile = null;
	358	}
	359	PrintStream resourceLoadStatsFile = null;
	360	try {
	361	File file = new File(outputFolderName + STATS_FILE_NAME_PREFIX
	362	+ simulationIdentifier + "_"
	363	+ RESOURCE_LOAD_STATISTICS_OUTPUT_FILE_NAME);
	364	resourceLoadStatsFile = new PrintStream(new FileOutputStream(file));
	365	} catch (IOException e) {
	366	resourceLoadStatsFile = null;
	367	}
	368	PrintStream energyStatsFile = null;
	369	try {
	370	File file = new File(outputFolderName + STATS_FILE_NAME_PREFIX
	371	+ simulationIdentifier + "_"
	372	+ ENERGYUSAGE_STATISTICS_OUTPUT_FILE_NAME);
	373	energyStatsFile = new PrintStream(new FileOutputStream(file));
	374	} catch (IOException e) {
	375	energyStatsFile = null;
	376	}
	377
	378	PrintStream resourceAccumulatedStatsFile = null;
	379	if (configuration.createaccumulatedresourcesstatistics) {
	380	try {
	381	File file = new File(outputFolderName + STATS_FILE_NAME_PREFIX
	382	+ simulationIdentifier + "_"
	383	+ ACCUMULATED_RESOURCES_STATISTICS_OUTPUT_FILE_NAME);
	384	resourceAccumulatedStatsFile = new PrintStream(
	385	new FileOutputStream(file));
	386
	387	} catch (IOException e) {
	388	resourceAccumulatedStatsFile = null;
	389	}
	390	}
	391	ganttDiagramResources = new ArrayList<XYDataset>();
	392	ganttDiagramProcessorsTimetable = new Timetable(new FixedMillisecond(
	393	startSimulationTime), new FixedMillisecond(endSimulationTime));
	394	ganttDiagramResourcesEnergy = new ArrayList<XYDataset>();
	395
	396	for (int i = 0; i < gridResources.length; i++) {
	397
	398	ResourceStats resourceStats = new ResourceStats(gridResources[i]);
	399
	400	gatherResourceCharacteristic(resourceStats, gridResources[i]);
	401
	402	gatherResourceQueueStats(resourceStats, gridResources[i]);
	403
	404	ResourceUsageStats resourceUsage = gatherResourceLoadStats(resourceStats, gridResources[i]);
	405
	406	ResourceUsageStats energyUsage = gatherResourceEnergyStats(resourceStats, gridResources[i]);
	407
	408	if (configuration.creatediagrams_resources) {
	409	// createResourceGanttDiagram(gridResources[i]);
	410	createResourceGanttDiagram(resourceUsage);
	411	}
	412	if (configuration.creatediagrams_processors) {
	413	prepareProcessorsGanttData(gridResources[i]);
	414	}
	415	if (configuration.creatediagrams_energyusage) {
	416	createResourceEnergyGanttDiagram(energyUsage);
	417	}
	418
	419	AbstractAllocationPolicy ap = gridResources[i]
	420	.getAllocationPolicy();
	421	for (Integer gridletID : ap.getAllocationHistory().keySet()) {
	422
	423	Map<String, Object> historyItem = (Map<String, Object>) ap
	424	.getAllocationHistory().get(gridletID);
	425	List<ResourceHistoryItem> resHistItemList = (List<ResourceHistoryItem>) historyItem
	426	.get(GssimConstants.RESOURCES);
	427	Map<ResourceParameterName, ResourceUnit> res = resHistItemList.get(resHistItemList.size() - 1).getResourceUnits();
	428
	429	ResourceUnit unit = res.get(ResourceParameterName.CPUCOUNT);
	430	if (unit instanceof ResourceProcessors) {
	431	ResourceProcessors processors = (ResourceProcessors) unit;
	432
	433	for (int proc = 0; proc < processors.getAmount(); proc++) {
	434	String processorName = proc
	435	+ "@"
	436	+ gridResources[i].getResourceCharacteristics()
	437	.getResourceName();
	438	if (processors.get(proc).getStatus() == Processor.Status.FREE)
	439	continue;
	440	SubmittedTask st = ap.getSubmittedTask(gridletID);
	441	gatherProcessorsLoadStats(resourceStats, processorName,
	442	historyItem);
	443	gatherProcessorsReservationLoadStats(resourceStats,
	444	gridResources[i], processorName, st.getJobId(),
	445	st.getId());
	446	String uniqueTaskID = st.getJobId() + "_" + st.getId();
	447	// task_processorMap.put(uniqueTaskID, processorName);
	448	List<String> procNames = task_processorsMap
	449	.get(uniqueTaskID);
	450	if (procNames == null) {
	451	procNames = new ArrayList<String>();
	452	procNames.add(processorName);
	453	task_processorsMap.put(uniqueTaskID, procNames);
	454	} else {
	455	procNames.add(processorName);
	456	// task_processorsMap.put(uniqueTaskID, procNames);
	457	}
	458	if (configuration.creatediagrams_processors) {
	459	createProcessorsGanttDiagram(processorName,
	460	uniqueTaskID, historyItem);
	461	}
	462	}
	463	}
	464	}
	465
	466	collectReservations(gridResources[i]);
	467	collectReservationsAsMap(gridResources[i]);
	468	collectReceivedNetworkData(gridResources[i]);
	469
	470	this.serializer.setFieldSeparator(RESOURCE_SEPARATOR);
	471	if (resourceStatsFile != null) {
	472	Object txt = resourceStats.serialize(this.serializer);
	473	resourceStatsFile.println(txt);
	474	}
	475
	476	if (configuration.createaccumulatedresourcesstatistics) {
	477	AccumulatedResourceStats accResStats = createAccumulatedResourceStatistic(resourceStats);
	478	if (resourceAccumulatedStatsFile != null) {
	479	Object txt = accResStats.serialize(this.serializer);
	480	resourceAccumulatedStatsFile.println(txt);
	481	}
	482	}
	483
	484	if (resourceLoadStatsFile != null) {
	485	Object txt = resourceUsage.serialize(this.serializer);
	486	resourceLoadStatsFile.println(txt);
	487	}
	488
	489	if (energyStatsFile != null) {
	490	Object txt = energyUsage.serialize(this.serializer);
	491	energyStatsFile.println(txt);
	492	}
	493
	494	if (configuration.createsimulationstatistics) {
	495	createAccumulatedResourceSimulationStatistic(resourceStats, energyUsage);
	496	}
	497	}
	498	saveResourceGanttDiagrams();
	499	if (resourceStatsFile != null) {
	500	resourceStatsFile.close();
	501	}
	502	if (resourceAccumulatedStatsFile != null) {
	503	resourceAccumulatedStatsFile.close();
	504	}
	505	if (energyStatsFile != null) {
	506	energyStatsFile.close();
	507	}
	508	}
	509
	510	private void gatherResourceCharacteristic(ResourceStats resourceStats,
	511	AbstractComputingResource gridResource) {
	512
	513	ResourceUnitsManagerImpl rum = (ResourceUnitsManagerImpl) gridResource
	514	.getResourceCharacteristics();
	515	Map<ResourceParameterName, ResourceUnit> resources = rum
	516	.getResourceParameters();
	517
	518	// resourceStats.resourceName =
	519	// gridResource.getResourceCharacteristics().getResourceName();
	520	ResourceUnit unit = resources.get(ResourceParameterName.MEMORY);
	521	resourceStats.memory = (unit == null ? 0 : unit.getAmount());
	522	resourceStats.cpucnt = rum.getNumPE();
	523
	524	unit = resources.get(ResourceParameterName.CPUCOUNT);
	525	if (unit instanceof Processors) {
	526	Processors peUnit = (Processors) unit;
	527	resourceStats.cpuspeed = peUnit.getProcessorSpeed();
	528	}
	529	}
	530
	531	private void gatherResourceQueueStats(ResourceStats resourceStats,
	532	AbstractComputingResource gridResource) {
	533
	534	Sim_stat stats = gridResource.getAllocationPolicy().get_stat();
	535	List<Object[]> measures = stats.get_measures();
	536	for (Object[] info : measures) {
	537	String measure = (String) info[0];
	538	if (measure
	539	.startsWith(GssimConstants.TASKS_QUEUE_LENGTH_MEASURE_NAME)) {
	540	resourceStats.setQueueLength(stats.average(measure));
	541	}
	542	}
	543	}
	544
	545	private ResourceUsageStats gatherResourceLoadStats(ResourceStats resourceStats,
	546	AbstractComputingResource gridResource) {
	547
	548	ResourceUsageStats usageStats = new ResourceUsageStats(resourceStats.getResourceName(), "resourceLoadStats");
	549
	550	// int nCPU = gridResource.getResourceCharacteristics().getNumPE();
	551	AbstractAllocationPolicy ap = gridResource.getAllocationPolicy();
	552
	553	TreeMap<Long, Integer> resourceLoadData = createResourceLoadData(
	554	usageStats, ap.getAllocationHistory());
	555	if (!resourceLoadData.containsKey(startSimulationTime))
	556	resourceLoadData.put(startSimulationTime, 0);
	557	// ganttdata.put(endSimulationTime, nCPU);
	558
	559	return usageStats;
	560	}
	561
	562	private TreeMap<Long, Integer> createResourceLoadData(ResourceUsageStats usageStats,
	563	Map<Integer, Map<String, Object>> history) {
	564
	565	TreeMap<Long, Integer> ganttData = (TreeMap) usageStats.getUsage();
	566	for (Map<String, Object> historyItem : history.values()) {
	567
	568	List<ResourceHistoryItem> resHistItemList = (List<ResourceHistoryItem>) historyItem
	569	.get(GssimConstants.RESOURCES);
	570	Map<ResourceParameterName, ResourceUnit> res = resHistItemList.get(resHistItemList.size() - 1).getResourceUnits();
	571
	572	ResourceUnit unit = res.get(ResourceParameterName.CPUCOUNT);
	573	int nCPU = Float.valueOf(unit.getUsedAmount()).intValue();
	574	long start_time = ((DateTime) historyItem
	575	.get(GssimConstants.START_TIME)).getMillis();
	576	long end_time = ((DateTime) historyItem
	577	.get(GssimConstants.END_TIME)).getMillis();
	578	if (end_time > start_time) {
	579	Integer end = ganttData.get(end_time);
	580	if (end == null) {
	581	ganttData.put(end_time, 0);
	582	Long left = getLeftKey(ganttData, end_time);
	583	if (left != null) {
	584	Integer leftValue = ganttData.get(left);
	585	ganttData.put(end_time, leftValue);
	586	}
	587	}
	588
	589	Integer start = ganttData.get(start_time);
	590	if (start == null) {
	591	ganttData.put(start_time, 0);
	592	Long left = getLeftKey(ganttData, start_time);
	593	if (left != null) {
	594	Integer leftValue = ganttData.get(left);
	595	ganttData.put(start_time, leftValue);
	596	}
	597	}
	598
	599	SortedMap<Long, Integer> sm = ganttData.subMap(start_time,
	600	end_time);
	601	for (Long key : sm.keySet()) {
	602	Integer keyVal = ganttData.get(key);
	603	ganttData.put(key, keyVal + nCPU);
	604	}
	605	}
	606	}
	607	return ganttData;
	608	}
	609
	610	private Long getLeftKey(TreeMap<Long, Integer> ganttData, Long toKey) {
	611
	612	SortedMap<Long, Integer> sm = ganttData.headMap(toKey);
	613	if (sm.isEmpty()) {
	614	return null;
	615	}
	616	return sm.lastKey();
	617	}
	618
	619	private ResourceUsageStats gatherResourceEnergyStats(ResourceStats resourceStats,
	620	AbstractComputingResource gridResource) {
	621
	622	ResourceUsageStats resEnergyUsage = new ResourceUsageStats(resourceStats.getResourceName(), "resourceEnergyStats");
	623	Map<Long, Integer> usage = resEnergyUsage.getUsage();
	624
	625	AbstractAllocationPolicy ap = gridResource.getAllocationPolicy();
	626	for (Object o : ap.getPowerUsage()) {
	627	PowerUsage energyUsage = (PowerUsage) o;
	628	usage.put(energyUsage.getTimestamp(),
	629	energyUsage.getValue());
	630	}
	631
	632	return resEnergyUsage;
	633	}
	634
	635	private void gatherProcessorsLoadStats(ResourceStats resourceStats,
	636	String processorName, Map<String, Object> historyItem) {
	637
	638	Map<String, Double> processorsLoad = resourceStats.getProcessorsLoad();
	639	Double load = processorsLoad.get(processorName);
	640	long startDate = ((DateTime) historyItem.get(GssimConstants.START_TIME))
	641	.getMillis();
	642	long endDate = ((DateTime) historyItem.get(GssimConstants.END_TIME))
	643	.getMillis();
	644	double newLoad = ((double) (endDate - startDate) / (double) (endSimulationTime - startSimulationTime));
	645	load += newLoad;
	646	processorsLoad.put(processorName, load);
	647
	648	}
	649
	650	private void gatherProcessorsReservationLoadStats(
	651	ResourceStats resourceStats,
	652	AbstractComputingResource gridResource, String processorName,
	653	String jobID, String taskID) {
	654	Map<String, Double> reservationLoad = resourceStats
	655	.getProcessorsReservationLoad();
	656	AbstractAllocationPolicy ap = gridResource.getAllocationPolicy();
	657	if (ap instanceof ARAllocationPolicy) {
	658	ARAllocationPolicy arap = (ARAllocationPolicy) ap;
	659	for (Reservation reservation : arap.getReservations()) {
	660	if (reservation.getStatus() != Reservation.Status.CANCELED
	661	&& reservation.getJobId().equals(jobID)
	662	&& reservation.getTaskId().equals(taskID)) {
	663	TimeResourceAllocation tra = reservation;
	664	Double load = reservationLoad.get(processorName);
	665	double newLoad = ((double) (tra.getEndMillis() - tra
	666	.getStartMillis()) / (double) (endSimulationTime - startSimulationTime));
	667	load += newLoad;
	668	reservationLoad.put(processorName, load);
	669	}
	670	}
	671	}
	672	}
	673
	674	private void collectReservations(AbstractComputingResource gridResource) {
	675
	676	AbstractAllocationPolicy ap = gridResource.getAllocationPolicy();
	677
	678	if (ap instanceof ARAllocationPolicy) {
	679	ARAllocationPolicy arap = (ARAllocationPolicy) ap;
	680	reservations.addAll(arap.getReservations());
	681	}
	682	}
	683
	684	private void collectReceivedNetworkData(
	685	AbstractComputingResource gridResource) {
	686
	687	receivedNetData.addAll(gridResource.getReceivedNetData());
	688	}
	689
	690	private void collectReservationsAsMap(AbstractComputingResource gridResource) {
	691
	692	AbstractAllocationPolicy ap = gridResource.getAllocationPolicy();
	693
	694	if (ap instanceof ARAllocationPolicy) {
	695	ARAllocationPolicy arap = (ARAllocationPolicy) ap;
	696	for (Reservation reservation : arap.getReservations()) {
	697	reservationsMap.put((reservation.getJobId() + "_" + reservation
	698	.getTaskId()), reservation);
	699	}
	700	}
	701	}
	702
	703	private AccumulatedResourceStats createAccumulatedResourceStatistic(ResourceStats resourceStats) {
	704
	705	AccumulatedResourceStats accResStats = new AccumulatedResourceStats(resourceStats.getResourceName());
	706
	707	for (String key : resourceStats.processorsLoad.keySet()) {
	708	double load = (double) resourceStats.processorsLoad.get(key);
	709	accResStats.addResourceLoad(load);
	710	}
	711	for (String key : resourceStats.processorsReservationLoad.keySet()) {
	712	double load = (double) resourceStats.processorsReservationLoad
	713	.get(key);
	714	accResStats.addReservationLoad(load);
	715	}
	716
	717	return accResStats;
	718	}
	719
	720	private void createAccumulatedResourceSimulationStatistic(
	721	ResourceStats resourceStats, ResourceUsageStats energyUsage) {
	722
	723	accStats.meanQueueLength.add(resourceStats.getQueueLength());
	724
	725	GSSAccumulator tempMeanLoad = new GSSAccumulator();
	726	for (String key : resourceStats.getProcessorsLoad().keySet()) {
	727	double load = (double) resourceStats.getProcessorsLoad().get(key);
	728	tempMeanLoad.add(load);
	729	}
	730
	731	GSSAccumulator tempReservationLoad = new GSSAccumulator();
	732	for (String key : resourceStats.getProcessorsReservationLoad().keySet()) {
	733	double load = (double) resourceStats.getProcessorsReservationLoad()
	734	.get(key);
	735	tempReservationLoad.add(load);
	736	}
	737	long time = 0;
	738	double tempLoad = 0;
	739	GSSAccumulator tempMeanEnergyUsage = new GSSAccumulator();
	740	Map<Long, Integer> usage = energyUsage.getUsage();
	741	for (Long key : usage.keySet()) {
	742	double load = (double) usage.get(key);
	743	if (time != 0) {
	744	tempLoad += (load * (key - time))
	745	/ (endSimulationTime - startSimulationTime);
	746	time = key;
	747	} else {
	748	time = key;
	749	}
	750
	751	}
	752	tempMeanEnergyUsage.add(tempLoad);
	753	for (int cpu = 0; cpu < resourceStats.cpucnt; cpu++) {
	754	accStats.meanTotalLoad.add(tempMeanLoad.getMean());
	755	accStats.meanReservationLoad.add(tempReservationLoad.getMean());
	756	accStats.meanEnergyUsage.add(tempMeanEnergyUsage.getMean());
	757	}
	758	}
	759
	760	/*
	761	* private void createResourceGanttDiagram( AbstractComputingResource
	762	* gridResource) {
	763	*
	764	* String resourceName = gridResource.getResourceCharacteristics()
	765	* .getResourceName(); int numPE =
	766	* gridResource.getResourceCharacteristics().getNumPE();
	767	* AbstractAllocationPolicy ap = gridResource.getAllocationPolicy();
	768	*
	769	* XYDataset dataset = createResourceGanttDataSet(resourceName, numPE, ap
	770	* .getAllocationHistory(), startSimulationTime, endSimulationTime);
	771	* ganttDiagramResources.add(dataset);
	772	*
	773	* }
	774	*
	775	* private XYDataset createResourceGanttDataSet(String resourceName, int
	776	* nCPU, Map<Integer, Map<String, Object>> history, long start, long end) {
	777	*
	778	* TreeMap<Long, Integer> ganttdata = createResourceGanttData(history);
	779	* XYSeriesCollection dataset = new XYSeriesCollection(); XYSeries data =
	780	* new XYSeries(resourceName, false, true); data.add(start, 0); for (Long
	781	* key : ganttdata.keySet()) { Integer val = ganttdata.get(key);
	782	* data.add(key, val); } data.add(end, nCPU); dataset.addSeries(data);
	783	* return dataset; }
	784	*/
	785
	786	private void createResourceGanttDiagram(ResourceUsageStats resStats) {
	787
	788	XYDataset dataset = createResourceGanttDataSet(resStats);
	789	ganttDiagramResources.add(dataset);
	790
	791	}
	792
	793	private XYDataset createResourceGanttDataSet(ResourceUsageStats resStats) {
	794
	795	XYSeriesCollection dataset = new XYSeriesCollection();
	796	XYSeries data = new XYSeries(resStats.resourceName, false, true);
	797	Map<Long, Integer> usage = resStats.getUsage();
	798
	799	for (Long key : usage.keySet()) {
	800	Integer val = usage.get(key);
	801	data.add(key, val);
	802	}
	803	dataset.addSeries(data);
	804	return dataset;
	805	}
	806
	807	private void prepareProcessorsGanttData(
	808	AbstractComputingResource gridResource) {
	809
	810	String resourceName = gridResource.getResourceCharacteristics()
	811	.getResourceName();
	812	int numPE = gridResource.getResourceCharacteristics().getNumPE();
	813
	814	for (int cpu = 0; cpu < numPE; cpu++) {
	815	String processorName = cpu + "@" + resourceName;
	816
	817	TimetableEventSource proc = new TimetableEventSource(processorName);
	818	ganttDiagramProcessorsTimetable.addEventSource(proc);
	819
	820	processorsGanttMap.put(processorName, proc);
	821	}
	822	}
	823
	824	private void createProcessorsGanttDiagram(String processorName,
	825	String uniqueTaskID, Map<String, Object> historyItem) {
	826	TimetableEventSource proc = processorsGanttMap.get(processorName);
	827	TimetableEventGroup task = taskGanttMap.get(uniqueTaskID);
	828	long startDate = ((DateTime) historyItem.get(GssimConstants.START_TIME))
	829	.getMillis();
	830	long endDate = ((DateTime) historyItem.get(GssimConstants.END_TIME))
	831	.getMillis();
	832	if (task == null) {
	833	task = new TimetableEventGroup(uniqueTaskID);
	834	taskGanttMap.put(uniqueTaskID, task);
	835	ganttDiagramProcessorsTimetable.addEventGroup(task);
	836	}
	837	ganttDiagramProcessorsTimetable.addEvent(proc, task,
	838	new FixedMillisecond(startDate), new FixedMillisecond(endDate));
	839	}
	840
	841	private void createResourceEnergyGanttDiagram(ResourceUsageStats energyUsage) {
	842
	843	XYDataset dataset = createResourceEnergyGanttDataSet(energyUsage,
	844	startSimulationTime, endSimulationTime);
	845	ganttDiagramResourcesEnergy.add(dataset);
	846
	847	}
	848
	849	private XYDataset createResourceEnergyGanttDataSet(
	850	ResourceUsageStats energyUsage, long start, long end) {
	851
	852	TreeMap<Long, Integer> ganttdata = createResourceEnergyGanttData(energyUsage);
	853	XYSeriesCollection dataset = new XYSeriesCollection();
	854	XYSeries data = new XYSeries(energyUsage.getResourceName(), false, true);
	855	data.add(start, 0);
	856	for (Long key : ganttdata.keySet()) {
	857	Integer val = ganttdata.get(key);
	858	data.add(key, val);
	859	}
	860	data.add(end, 0);
	861	dataset.addSeries(data);
	862	return dataset;
	863	}
	864
	865	private TreeMap<Long, Integer> createResourceEnergyGanttData(
	866	ResourceUsageStats energyUsage) {
	867
	868	Map<Long, Integer> usage = energyUsage.getUsage();
	869	TreeMap<Long, Integer> ganttData = new TreeMap<Long, Integer>();
	870	for (Long euKey : usage.keySet()) {
	871
	872	ganttData.put(euKey, usage.get(euKey));
	873	}
	874	return ganttData;
	875	}
	876
	877	private boolean saveResourceGanttDiagrams() {
	878
	879	JFreeChart processorsDiagram = null;
	880	JFreeChart resourceDiagram = null;
	881	JFreeChart resourceEnergyDiagram = null;
	882	if (!generateDiagrams)
	883	return false;
	884
	885	String fileName = new File(outputFolderName, DIAGRAMS_FILE_NAME_PREFIX
	886	+ simulationIdentifier + "_").getAbsolutePath();
	887
	888	String chartName = "Gantt diagram for "
	889	+ GridSchedulingSimulator.SIMULATOR_NAME;
	890	String simulationTime = "Simulation time";
	891	Title subtitle = new TextTitle("created for \"" + simulationIdentifier
	892	+ "\" at " + Calendar.getInstance().getTime().toString());
	893
	894	if (configuration.creatediagrams_processors) {
	895	processorsDiagram = getProcessorsDiagram(chartName, subtitle,
	896	simulationTime);
	897	if (!saveCategoryChart(processorsDiagram, fileName + "Processors",
	898	"{0}"))
	899	return false;
	900	}
	901
	902	if (configuration.creatediagrams_resources) {
	903	resourceDiagram = getResourcesDiagram(chartName, subtitle,
	904	simulationTime);
	905	if (!saveXYPlotChart(resourceDiagram, fileName + "Resources"))
	906	return false;
	907	}
	908
	909	if (configuration.creatediagrams_energyusage) {
	910	resourceEnergyDiagram = getResourcesEnergyDiagram(chartName,
	911	subtitle, simulationTime);
	912	if (!saveXYPlotChart(resourceEnergyDiagram, fileName + "Energy"))
	913	return false;
	914	}
	915	return true;
	916	}
	917
	918	private JFreeChart getProcessorsDiagram(String chartName, Title subtitle,
	919	String simulationTime) {
	920	String processors = "Processors";
	921	boolean tooltip = true;
	922	boolean legend = true;
	923	JFreeChart chart = TimetableChartFactory.createTimetableChart(
	924	chartName, processors, simulationTime,
	925	ganttDiagramProcessorsTimetable, legend, tooltip);
	926	chart.addSubtitle(subtitle);
	927	TimetableRenderer rend = (TimetableRenderer) chart.getCategoryPlot()
	928	.getRenderer();
	929	rend.setBackgroundBarPaint(null);
	930	return chart;
	931	}
	932
	933	private JFreeChart getResourcesDiagram(String chartName, Title subtitle,
	934	String simulationTime) {
	935	String cpu = "CPU";
	936	boolean urls = false;
	937	boolean tooltip = true;
	938	boolean legend = true;
	939	CombinedDomainXYPlot cPlot = new CombinedDomainXYPlot();
	940	DateAxis xAxis = new DateAxis(simulationTime);
	941
	942	for (XYDataset dataset : ganttDiagramResources) {
	943
	944	JFreeChart tChart = ChartFactory.createXYStepAreaChart("", "",
	945	null, dataset, PlotOrientation.VERTICAL, legend, tooltip,
	946	urls);
	947
	948	XYPlot tPlot = tChart.getXYPlot();
	949	NumberAxis yAxis = new NumberAxis(cpu);
	950	yAxis.setStandardTickUnits(NumberAxis.createIntegerTickUnits());
	951	tPlot.setRangeAxis(yAxis);
	952	XYStepAreaRenderer rend = (XYStepAreaRenderer) tPlot.getRenderer();
	953	rend.setShapesVisible(false);
	954	cPlot.add(tPlot);
	955	}
	956	cPlot.setDomainAxis(xAxis);
	957	cPlot.setDomainAxisLocation(AxisLocation.TOP_OR_LEFT);
	958	JFreeChart chart = new JFreeChart(chartName, cPlot);
	959	chart.addSubtitle(subtitle);
	960	return chart;
	961	}
	962
	963	private JFreeChart getResourcesEnergyDiagram(String chartName,
	964	Title subtitle, String simulationTime) {
	965	String energy = "ENERGY [W]";
	966	boolean urls = false;
	967	boolean tooltip = true;
	968	boolean legend = true;
	969	CombinedDomainXYPlot cPlot = new CombinedDomainXYPlot();
	970	DateAxis xAxis = new DateAxis(simulationTime);
	971
	972	for (XYDataset dataset : ganttDiagramResourcesEnergy) {
	973
	974	JFreeChart tChart = ChartFactory.createXYStepAreaChart("", "",
	975	null, dataset, PlotOrientation.VERTICAL, legend, tooltip,
	976	urls);
	977
	978	XYPlot tPlot = tChart.getXYPlot();
	979	NumberAxis yAxis = new NumberAxis(energy);
	980	yAxis.setStandardTickUnits(NumberAxis.createIntegerTickUnits());
	981	tPlot.setRangeAxis(yAxis);
	982	XYStepAreaRenderer rend = (XYStepAreaRenderer) tPlot.getRenderer();
	983	rend.setShapesVisible(false);
	984	cPlot.add(tPlot);
	985	}
	986	cPlot.setDomainAxis(xAxis);
	987	cPlot.setDomainAxisLocation(AxisLocation.TOP_OR_LEFT);
	988	JFreeChart chart = new JFreeChart(chartName, cPlot);
	989	chart.addSubtitle(subtitle);
	990	return chart;
	991	}
	992
	993	/*********** TASK STATISTICS SECTION ************/
	994	public void gatherTaskStatistics() {
	995
	996	List<JobInterface<?>> jobs = users.getAllReceivedJobs();
	997	Collections.sort(jobs, new JobIdComparator());
	998
	999	ganttDiagramTaskSeriesCollection = new TaskSeriesCollection();
	1000	ganttDiagramWaitingTimeSeriesCollection = new TaskSeriesCollection();
	1001	ganttDiagramReservationSeriesCollection = new TaskSeriesCollection();
	1002
	1003	PrintStream taskStatsFile = null;
	1004	try {
	1005	File file = new File(outputFolderName + STATS_FILE_NAME_PREFIX
	1006	+ simulationIdentifier + "_"
	1007	+ RAW_TASKS_STATISTICS_OUTPUT_FILE_NAME);
	1008	taskStatsFile = new PrintStream(new FileOutputStream(file));
	1009	} catch (IOException e) {
	1010	taskStatsFile = null;
	1011	}
	1012
	1013	PrintStream jobStatsFile = null;
	1014	if (configuration.createjobsstatistics) {
	1015	try {
	1016	File file = new File(outputFolderName + STATS_FILE_NAME_PREFIX
	1017	+ simulationIdentifier + "_"
	1018	+ JOBS_STATISTICS_OUTPUT_FILE_NAME);
	1019	jobStatsFile = new PrintStream(new FileOutputStream(file));
	1020	} catch (IOException e) {
	1021	jobStatsFile = null;
	1022	}
	1023	}
	1024
	1025	if (configuration.creatediagrams_reservations)
	1026	prepareTaskReservationDiagramData();
	1027
	1028	for (int i = 0; i < jobs.size(); i++) {
	1029	Job job = (Job) jobs.get(i);
	1030
	1031	List<AbstractExecutable> execList = this.brokerInterface
	1032	.getExecutables().getJobExecutables(job.getId());
	1033	List<TaskStats> taskStatsList = new ArrayList<TaskStats>();
	1034
	1035	this.serializer.setFieldSeparator(TASK_SEPARATOR);
	1036
	1037	for (int j = 0; j < execList.size(); j++) {
	1038
	1039	AbstractExecutable task = execList.get(j);
	1040
	1041	TaskStats taskStats = createTaskStats(task);
	1042	if (taskStats != null && taskStatsFile != null) {
	1043	Object txt = taskStats.serialize(serializer);
	1044	taskStatsFile.println(txt);
	1045	}
	1046	if (taskStats != null && taskStats.getExecFinishDate() != -1) {
	1047	if (configuration.createsimulationstatistics) {
	1048	createAccumulatedTaskSimulationStatistic(taskStats);
	1049	}
	1050	allTasksFinished &= task.isFinished();
	1051	if (generateDiagrams) {
	1052	if (configuration.creatediagrams_tasks)
	1053	createTaskDiagramData(task);
	1054	if (configuration.creatediagrams_taskswaitingtime)
	1055	createTaskWaitingTimeDiagramData(task);
	1056	if (configuration.creatediagrams_reservations)
	1057	createTaskReservationDiagramData(task);
	1058	}
	1059	taskStatsList.add(taskStats);
	1060	}
	1061	}
	1062	if (configuration.createjobsstatistics && taskStatsList.size() > 0) {
	1063
	1064	this.serializer.setFieldSeparator(JOB_SEPARATOR);
	1065
	1066	JobStats jobStats = createJobStats(taskStatsList);
	1067	if (jobStatsFile != null) {
	1068	Object txt = jobStats.serialize(serializer);
	1069	jobStatsFile.println(txt);
	1070	}
	1071	}
	1072	}
	1073
	1074	if (configuration.createsimulationstatistics) {
	1075	accStats.makespan.add(maxCj);
	1076	accStats.delayedTasks.add(numOfdelayedTasks);
	1077	accStats.failedRequests.add(users.getAllSentTasks().size()
	1078	- users.getFinishedTasksCount());
	1079	createStatsData();
	1080	}
	1081
	1082	saveTaskGanttDiagrams();
	1083	saveGridletStatistics();
	1084
	1085	if (taskStatsFile != null) {
	1086	taskStatsFile.close();
	1087	}
	1088	if (jobStatsFile != null) {
	1089	jobStatsFile.close();
	1090	}
	1091	}
	1092
	1093	private TaskStats createTaskStats(AbstractExecutable task) {
	1094	TaskStats taskStats = new TaskStats(task, startSimulationTime);
	1095
	1096	String uniqueTaskID = taskStats.getJobID() + "_"
	1097	+ taskStats.getTaskID();
	1098
	1099	if (reservationsMap.containsKey(uniqueTaskID)) {
	1100	taskStats.setReservationStartDate(((Reservation) reservationsMap
	1101	.get(uniqueTaskID)).getStartMillis() / 1000);
	1102
	1103	taskStats.setReservationFinishDate(((Reservation) reservationsMap
	1104	.get(uniqueTaskID)).getEndMillis() / 1000);
	1105	}
	1106
	1107	taskStats.setProcessorsName(task_processorsMap.get(uniqueTaskID));
	1108
	1109	return taskStats;
	1110	}
	1111
	1112	/*
	1113	* private TaskStats createTaskStats(AbstractExecutable task) {
	1114	*
	1115	* TaskStats taskStats = new TaskStats(task.getJobId(), task.getId());
	1116	* taskStats.userDN = task.getUserDn(); String resNames[] =
	1117	* task.getAllResourceName(); if (resNames == null) return null; for (int i
	1118	* = 0; i < resNames.length; i++) { taskStats.resName += resNames[i]; if
	1119	* (resNames.length > 1) taskStats.resName += " "; } taskStats.execStartDate
	1120	* = task.getExecStartTime(); taskStats.execFinishDate =
	1121	* task.getFinishTime(); taskStats.gB_SubDate =
	1122	* task.getSubmissionTimeToBroker().getMillis() / 1000; taskStats.lB_SubDate
	1123	* = task.getSubmissionTime();
	1124	*
	1125	* try { taskStats.execEndDate = task.getExecutionEndTime().getMillis() /
	1126	* 1000; } catch (NoSuchFieldException e) { taskStats.execEndDate =
	1127	* task.getFinishTime(); }
	1128	*
	1129	* try { taskStats.cpuCnt = Double.valueOf(task.getCpuCntRequest())
	1130	* .longValue(); } catch (NoSuchFieldException e) { }
	1131	*
	1132	* taskStats.completionTime = task.getFinishTime() - startSimulationTime /
	1133	* 1000; taskStats.executionTime = task.getFinishTime() -
	1134	* task.getExecStartTime(); taskStats.execStartTime =
	1135	* task.getExecStartTime() - startSimulationTime / 1000;
	1136	*
	1137	* try { taskStats.readyTime = task.getExecutionStartTime().getMillis() /
	1138	* 1000 - startSimulationTime / 1000; } catch (Exception ex) {
	1139	* taskStats.readyTime = task.getSubmissionTime() - startSimulationTime /
	1140	* 1000; }
	1141	*
	1142	* taskStats.startTime = task.getExecStartTime() -
	1143	* task.getSubmissionTimeToBroker().getMillis() / 1000; taskStats.flowTime =
	1144	* taskStats.completionTime - taskStats.readyTime; taskStats.waitingTime =
	1145	* task.getWaitingTime(); taskStats.gQ_WaitingTime =
	1146	* task.getSubmissionTime() - task.getSubmissionTimeToBroker().getMillis() /
	1147	* 1000;
	1148	*
	1149	* if (taskStats.execEndDate != -1) { taskStats.lateness =
	1150	* task.getFinishTime() - taskStats.execEndDate; } taskStats.tardiness =
	1151	* Math.max(taskStats.lateness, 0.0); String uniqueTaskID = taskStats.jobID
	1152	* + "_" + taskStats.taskID;
	1153	*
	1154	* if (reservationsMap.containsKey(uniqueTaskID)) {
	1155	* taskStats.reservationStartDate = ((Reservation) reservationsMap
	1156	* .get(uniqueTaskID)).getStartMillis() / 1000;
	1157	* taskStats.reservationFinishDate = ((Reservation) reservationsMap
	1158	* .get(uniqueTaskID)).getEndMillis() / 1000; } taskStats.processorsName =
	1159	* task_processorsMap.get(uniqueTaskID); return taskStats; }
	1160	*/
	1161	private JobStats createJobStats(List<TaskStats> tasksStats) {
	1162
	1163	String jobID = ((TaskStats) tasksStats.get(0)).getJobID();
	1164	JobStats jobStats = new JobStats(jobID);
	1165	double maxCj = 0;
	1166
	1167	for (int i = 0; i < tasksStats.size(); i++) {
	1168
	1169	TaskStats task = (TaskStats) tasksStats.get(i);
	1170	jobStats.meanTaskStartTime.add(task.getStartTime());
	1171	jobStats.meanTaskCompletionTime.add(task.getCompletionTime());
	1172	maxCj = Math.max(maxCj, task.getCompletionTime());
	1173	jobStats.meanTaskExecutionTime.add(task.getExecutionTime());
	1174	jobStats.meanTaskWaitingTime.add(task.getWaitingTime());
	1175	jobStats.meanTaskFlowTime.add(task.getFlowTime());
	1176	jobStats.meanTaskGQ_WaitingTime.add(task.getGQ_WaitingTime());
	1177	jobStats.lateness.add(task.getLateness());
	1178	jobStats.tardiness.add(task.getTardiness());
	1179	}
	1180	jobStats.makespan.add(maxCj);
	1181
	1182	return jobStats;
	1183	}
	1184
	1185	private void createAccumulatedTaskSimulationStatistic(TaskStats taskStats) {
	1186	accStats.meanTaskFlowTime.add(taskStats.getFlowTime());
	1187	accStats.meanTaskExecutionTime.add(taskStats.getExecutionTime());
	1188	accStats.meanTaskCompletionTime.add(taskStats.getCompletionTime());
	1189	accStats.meanTaskWaitingTime.add(taskStats.getWaitingTime());
	1190	accStats.meanTaskStartTime.add(taskStats.getStartTime());
	1191
	1192	accStats.lateness.add(taskStats.getLateness());
	1193	accStats.tardiness.add(taskStats.getTardiness());
	1194
	1195	if (taskStats.getExecFinishDate() == -1) {
	1196	numOfNotExecutedTasks++;
	1197	}
	1198	if (taskStats.getTardiness() > 0.0) {
	1199	numOfdelayedTasks++;
	1200	}
	1201
	1202	maxCj = Math.max(maxCj, taskStats.getCompletionTime());
	1203	}
	1204
	1205	private void createTaskDiagramData(AbstractExecutable task) {
	1206	String uniqueTaskID = task.getJobId() + "_" + task.getId();
	1207
	1208	String resIDlist[] = task.getAllResourceName();
	1209	String resID = resIDlist[resIDlist.length - 1];
	1210
	1211	long execStartTime = Double.valueOf(task.getExecStartTime())
	1212	.longValue() * 1000;
	1213	long execEndTime = Double.valueOf(task.getFinishTime()).longValue() * 1000;
	1214
	1215	TaskSeries taskRes = ganttDiagramTaskSeriesCollection.getSeries(resID);
	1216	if (taskRes == null) {
	1217	taskRes = new TaskSeries(resID);
	1218	ganttDiagramTaskSeriesCollection.add(taskRes);
	1219	}
	1220	org.jfree.data.gantt.Task ganttTask = new org.jfree.data.gantt.Task(
	1221	uniqueTaskID, new Date(execStartTime), new Date(execEndTime));
	1222	if (!task.isFinished()) {
	1223	ganttTask.setPercentComplete(1.0);
	1224	}
	1225	taskRes.add(ganttTask);
	1226	}
	1227
	1228	private void createTaskWaitingTimeDiagramData(AbstractExecutable task) {
	1229	String uniqueTaskID = task.getJobId() + "_" + task.getId();
	1230
	1231	String resIDlist[] = task.getAllResourceName();
	1232	String resID = resIDlist[resIDlist.length - 1];
	1233
	1234	long execStartTime = Double.valueOf(task.getExecStartTime())
	1235	.longValue() * 1000;
	1236	long execEndTime = Double.valueOf(task.getFinishTime()).longValue() * 1000;
	1237
	1238	TaskSeries waitRes = ganttDiagramWaitingTimeSeriesCollection
	1239	.getSeries(resID);
	1240	if (waitRes == null) {
	1241	waitRes = new TaskSeries(resID);
	1242	ganttDiagramWaitingTimeSeriesCollection.add(waitRes);
	1243	}
	1244
	1245	long sub = Double.valueOf(task.getSubmissionTime()).longValue() * 1000;
	1246	org.jfree.data.gantt.Task wait_exec = new org.jfree.data.gantt.Task(
	1247	uniqueTaskID, new Date(sub), new Date(execEndTime));
	1248	org.jfree.data.gantt.Task exec = new org.jfree.data.gantt.Task(
	1249	uniqueTaskID, new Date(execStartTime), new Date(execEndTime));
	1250	if (!task.isFinished()) {
	1251	exec.setPercentComplete(1.0);
	1252	}
	1253	wait_exec.addSubtask(wait_exec);
	1254	wait_exec.addSubtask(exec);
	1255	waitRes.add(wait_exec);
	1256	}
	1257
	1258	private void prepareTaskReservationDiagramData() {
	1259
	1260	for (Reservation reservation : reservations) {
	1261	if (reservation.getStatus() != Reservation.Status.CANCELED) {
	1262	String jobID = reservation.getJobId();
	1263	String taskID = reservation.getTaskId();
	1264	String uniqueTaskID = jobID + "_" + taskID;
	1265	String resID = reservation.getResourceProvider()
	1266	.getProviderId();
	1267
	1268	TaskSeries resRes = ganttDiagramReservationSeriesCollection
	1269	.getSeries(resID);
	1270	if (resRes == null) {
	1271	resRes = new TaskSeries(resID);
	1272	ganttDiagramReservationSeriesCollection.add(resRes);
	1273	}
	1274
	1275	TimeResourceAllocation tra = reservation;
	1276	org.jfree.data.gantt.Task reserv = new org.jfree.data.gantt.Task(
	1277	uniqueTaskID, tra.getStart().toDate(), tra.getEnd()
	1278	.toDate());
	1279	reserv.addSubtask(reserv);
	1280	resRes.add(reserv);
	1281	}
	1282	}
	1283	}
	1284
	1285	private void createTaskReservationDiagramData(AbstractExecutable task) {
	1286	String uniqueTaskID = task.getJobId() + "_" + task.getId();
	1287
	1288	String resIDlist[] = task.getAllResourceName();
	1289	String resID = resIDlist[resIDlist.length - 1];
	1290
	1291	long execStartTime = Double.valueOf(task.getExecStartTime())
	1292	.longValue() * 1000;
	1293	long execEndTime = Double.valueOf(task.getFinishTime()).longValue() * 1000;
	1294
	1295	if (reservations.size() > 0) {
	1296	TaskSeries resRes = ganttDiagramReservationSeriesCollection
	1297	.getSeries(resID);
	1298	if (resRes == null) {
	1299	resRes = new TaskSeries(resID);
	1300	ganttDiagramReservationSeriesCollection.add(resRes);
	1301	}
	1302
	1303	org.jfree.data.gantt.Task reserv = resRes.get(uniqueTaskID);
	1304	if (reserv == null) {
	1305	if (log.isErrorEnabled())
	1306	log.error("TASK: " + uniqueTaskID
	1307	+ " is running without reservation!!!");
	1308	reserv = new org.jfree.data.gantt.Task(uniqueTaskID, new Date(
	1309	execStartTime), new Date(execEndTime));
	1310	resRes.add(reserv);
	1311	}
	1312	org.jfree.data.gantt.Task reservExec = new org.jfree.data.gantt.Task(
	1313	uniqueTaskID, new Date(execStartTime),
	1314	new Date(execEndTime));
	1315	if (!task.isFinished()) {
	1316	reservExec.setPercentComplete(1.0f);
	1317	}
	1318	reserv.addSubtask(reservExec);
	1319	}
	1320	}
	1321
	1322	private void saveGridletStatistics() {
	1323
	1324	PrintStream gridletStatsFile = null;
	1325	if (configuration.creategridlethistorystatistics) {
	1326	try {
	1327	File file = new File(outputFolderName + STATS_FILE_NAME_PREFIX
	1328	+ simulationIdentifier + "_"
	1329	+ GRIDLETS_STATISTICS_OUTPUT_FILE_NAME);
	1330	gridletStatsFile = new PrintStream(new FileOutputStream(file));
	1331	} catch (IOException e) {
	1332	e.printStackTrace();
	1333	}
	1334
	1335	List<JobInterface<?>> list = (List<JobInterface<?>>) users
	1336	.getAllReceivedJobs();
	1337	for (int i = 0; i < list.size(); i++) {
	1338	Job jobGridlet = (Job) list.get(i);
	1339	List<AbstractExecutable> executables = this.brokerInterface
	1340	.getExecutables().getJobExecutables(jobGridlet.getId());
	1341	for (int j = 0; j < executables.size(); j++) {
	1342	AbstractExecutable exec = executables.get(j);
	1343	gridletStatsFile.print(exec.getGridletHistory());
	1344
	1345	gridletStatsFile.print("Job ID: " + jobGridlet.getId()
	1346	+ " (Gridlet #" + exec.getGridletID() + ")");
	1347	gridletStatsFile.println(", length = "
	1348	+ exec.getGridletLength() + ", finished so far = "
	1349	+ exec.getGridletFinishedSoFar());
	1350	}
	1351	gridletStatsFile
	1352	.println("=========================================");
	1353	gridletStatsFile.println();
	1354	gridletStatsFile.flush();
	1355	}
	1356	}
	1357	if (gridletStatsFile != null) {
	1358	gridletStatsFile.close();
	1359	}
	1360	}
	1361
	1362	private boolean saveTaskGanttDiagrams() {
	1363
	1364	JFreeChart taskDiagram = null;
	1365	JFreeChart waitingTimeDiagram = null;
	1366	JFreeChart reservationsDiagram = null;
	1367
	1368	if (!generateDiagrams)
	1369	return false;
	1370
	1371	String fileName = new File(outputFolderName, DIAGRAMS_FILE_NAME_PREFIX
	1372	+ simulationIdentifier + "_").getAbsolutePath();
	1373
	1374	String chartName = "Gantt diagram for "
	1375	+ GridSchedulingSimulator.SIMULATOR_NAME;
	1376	String simulationTime = "Simulation time";
	1377	Title subtitle = new TextTitle("created for \"" + simulationIdentifier
	1378	+ "\" at " + Calendar.getInstance().getTime().toString());
	1379
	1380	if (configuration.creatediagrams_tasks) {
	1381	taskDiagram = getTaskDiagram(chartName, subtitle, simulationTime);
	1382	if (!saveCategoryChart(taskDiagram, fileName + "Tasks", null /* "{0}" */))
	1383	return false;
	1384	}
	1385
	1386	if (configuration.creatediagrams_taskswaitingtime) {
	1387	waitingTimeDiagram = getWaitingTimeDiagram(chartName, subtitle,
	1388	simulationTime);
	1389	if (!saveCategoryChart(waitingTimeDiagram, fileName
	1390	+ "Waiting_Time", null /* "Task {1} at {0}" */))
	1391	return false;
	1392	}
	1393
	1394	if (configuration.creatediagrams_reservations
	1395	&& reservations.size() > 0) {
	1396	reservationsDiagram = getReservationDiagram(chartName, subtitle,
	1397	simulationTime);
	1398	if (!saveCategoryChart(reservationsDiagram, fileName
	1399	+ "Reservations", "Task {1} at {0}"))
	1400	return false;
	1401	}
	1402
	1403	return true;
	1404	}
	1405
	1406	private JFreeChart getTaskDiagram(String chartName, Title subtitle,
	1407	String simulationTime) {
	1408	String tasks = "Tasks";
	1409	boolean urls = false;
	1410	boolean tooltip = true;
	1411	boolean legend = true;
	1412	JFreeChart chart = ChartFactory.createGanttChart(chartName, tasks,
	1413	simulationTime, ganttDiagramTaskSeriesCollection, legend,
	1414	tooltip, urls);
	1415	chart.addSubtitle(subtitle);
	1416	GanttRenderer re = (GanttRenderer) chart.getCategoryPlot()
	1417	.getRenderer();
	1418	re.setCompletePaint(Color.black);
	1419	return chart;
	1420	}
	1421
	1422	private JFreeChart getWaitingTimeDiagram(String chartName, Title subtitle,
	1423	String simulationTime) {
	1424	String tasks = "Tasks";
	1425	boolean urls = false;
	1426	boolean tooltip = true;
	1427	boolean legend = true;
	1428	JFreeChart chart = ChartFactory.createGanttChart(chartName, tasks,
	1429	simulationTime, ganttDiagramWaitingTimeSeriesCollection,
	1430	legend, tooltip, urls);
	1431	chart.addSubtitle(subtitle);
	1432	chart.getPlot().setForegroundAlpha(ALPHA);
	1433	GanttRenderer re = (GanttRenderer) chart.getCategoryPlot()
	1434	.getRenderer();
	1435	re.setCompletePaint(Color.black);
	1436	return chart;
	1437	}
	1438
	1439	private JFreeChart getReservationDiagram(String chartName, Title subtitle,
	1440	String simulationTime) {
	1441	String tasks = "Tasks";
	1442	boolean urls = false;
	1443	boolean tooltip = true;
	1444	boolean legend = true;
	1445	JFreeChart chart = ChartFactory.createGanttChart(chartName, tasks,
	1446	simulationTime, ganttDiagramReservationSeriesCollection,
	1447	legend, tooltip, urls);
	1448	chart.addSubtitle(subtitle);
	1449	chart.getPlot().setForegroundAlpha(ALPHA);
	1450	GanttRenderer re = (GanttRenderer) chart.getCategoryPlot()
	1451	.getRenderer();
	1452	re.setCompletePaint(Color.black);
	1453	return chart;
	1454	}
	1455
	1456	/*********** NETWORK STATISTICS SECTION ************/
	1457	public void gatherNetworkStatistics() {
	1458
	1459	PrintStream netStatsFile = null;
	1460	if (topology != null) {
	1461	try {
	1462	File file = new File(outputFolderName + STATS_FILE_NAME_PREFIX
	1463	+ simulationIdentifier + "_"
	1464	+ NETWORK_SIMULATION_STATISTICS_OUTPUT_FILE_NAME);
	1465	netStatsFile = new PrintStream(new FileOutputStream(file));
	1466	} catch (IOException e) {
	1467	netStatsFile = null;
	1468	}
	1469	if (netStatsFile != null) {
	1470
	1471	for (int i = 0; i < topology.getLinks().size(); i++) {
	1472
	1473	GSSIMFlowLink link = (GSSIMFlowLink) topology.getLinks()
	1474	.get(i);
	1475	LinkStats linkStats = createLinkStats(link);
	1476	Object txt = linkStats.serialize(this.serializer);
	1477	netStatsFile.println(txt);
	1478	}
	1479
	1480	{
	1481	List<NetworkReservationObject> networkReservations = ((NetworkGridBroker) brokerInterface)
	1482	.getReservations();
	1483	for (int i = 0; i < networkReservations.size(); i++) {
	1484	NetworkReservationStats resStats = createNetworkReservationStats(networkReservations
	1485	.get(i));
	1486	Object txt = resStats.serialize(this.serializer);
	1487	netStatsFile.println(txt);
	1488	}
	1489
	1490	}
	1491	/*
	1492	* if (configuration.formatstatisticsoutput)
	1493	* printFormatedLinkReservationStatsHeader(netStatsFile); else
	1494	* printLinkReservationStatsHeader(netStatsFile); for (int i =
	1495	* 0; i < topology.getLinks().size(); i++) {
	1496	*
	1497	* GSSIMFlowLink link = (GSSIMFlowLink) topology.getLinks()
	1498	* .get(i); LinkStats linkStats =
	1499	* createLinkReservationStats(link); if
	1500	* (configuration.formatstatisticsoutput)
	1501	* saveFormatedLinkReservationStats(linkStats, netStatsFile);
	1502	* else saveLinkReservationStats(linkStats, netStatsFile); }
	1503	*/
	1504	printNetworkDataStatsHeader(netStatsFile);
	1505	saveNetworkDataStats(netStatsFile);
	1506	netStatsFile.close();
	1507	}
	1508	}
	1509	}
	1510
	1511	private LinkStats createLinkStats(GSSIMFlowLink link) {
	1512
	1513	LinkStats linkStats = new LinkStats(link.get_name());
	1514	double flowsSize = 0;
	1515	double duration = (this.endSimulationTime - this.startSimulationTime)
	1516	/ GSSimStatistics.MILLI_SEC;
	1517	ArrayList fsc = (ArrayList) link.getFlowsSizeCharacteristic();
	1518	for (int i = 0; i < fsc.size(); i++) {
	1519	flowsSize += (Long) fsc.get(i);
	1520	}
	1521	linkStats.flowsSize = flowsSize;
	1522	double allReservationsSize = 0;
	1523	ArrayList arl = (ArrayList) link.getCompletedReservationsList();
	1524	for (int i = 0; i < arl.size(); i++) {
	1525	NetworkReservationObject netResObj = (NetworkReservationObject) arl
	1526	.get(i);
	1527	allReservationsSize += (netResObj.getDuration() * netResObj
	1528	.getBandwidth())
	1529	/ GSSimStatistics.MILLI_SEC;
	1530	}
	1531	linkStats.startBaduRate = link.getStartBaduRate();
	1532	linkStats.delay = link.getDelay();
	1533	linkStats.load = (GSSimStatistics.BITS * flowsSize + allReservationsSize)
	1534	/ (link.getStartBaduRate() * duration);
	1535	linkStats.reservationLoad = allReservationsSize
	1536	/ (link.getStartBaduRate() * duration);
	1537	// linkStats.createLinkReservationStatistics(link);
	1538	return linkStats;
	1539	}
	1540
	1541	private NetworkReservationStats createNetworkReservationStats(
	1542	NetworkReservationObject netResObj) {
	1543
	1544	NetworkReservationStats resStats = new NetworkReservationStats(
	1545	netResObj.getReservationID());
	1546	double flowsSize = 0;
	1547	resStats.route = netResObj.getLinksNames();
	1548	resStats.startTime = netResObj.getStartTime();
	1549	resStats.endTime = netResObj.getEndTime();
	1550	resStats.bandwidth = netResObj.getBandwidth();
	1551	if (netResObj.getStatus() == ExtendedGridSimTags.RESERVATION_CANCELED)
	1552	resStats.status = "CANCELED";
	1553	else
	1554	resStats.status = "FINISHED";
	1555	Iterator it = netResObj.getLinks().iterator();
	1556	while (it.hasNext()) {
	1557	flowsSize = 0;
	1558	GSSIMFlowLink link = (GSSIMFlowLink) it.next();
	1559	ArrayList fursc = (ArrayList) link
	1560	.getFlowsUsingReservationsCharacteristic().get(
	1561	netResObj.getReservationID());
	1562	if (fursc == null)
	1563	continue;
	1564	for (int i = 0; i < fursc.size(); i++) {
	1565	flowsSize += (Long) fursc.get(i);
	1566	}
	1567	resStats.flowsSize = flowsSize;
	1568	resStats.load = (GSSimStatistics.BITS * flowsSize)
	1569	/ ((netResObj.getBandwidth() * netResObj.getDuration()) / GSSimStatistics.MILLI_SEC);
	1570	break;
	1571	}
	1572	return resStats;
	1573	}
	1574
	1575
	1576	/*
	1577	* private LinkStats createLinkReservationStats(GSSIMFlowLink link) {
	1578	*
	1579	* LinkStats linkStats = new LinkStats(link.get_name());
	1580	* linkStats.createLinkReservationStatistics(link); return linkStats; }
	1581	*/
	1582
	1583	private void printNetworkDataStatsHeader(PrintStream outStream) {
	1584
	1585	outStream.print("JobID");
	1586	outStream.print(TASK_SEPARATOR);
	1587	outStream.print("TaskID");
	1588	outStream.print(TASK_SEPARATOR);
	1589	outStream.print("file name");
	1590	outStream.print(TASK_SEPARATOR);
	1591	outStream.print("data route");
	1592	outStream.print(NETWORK_SEPARATOR);
	1593	outStream.print("start date");
	1594	outStream.print(NETWORK_SEPARATOR);
	1595	outStream.print("end date");
	1596	outStream.print(NETWORK_SEPARATOR);
	1597	outStream.print("reservation ID");
	1598	outStream.println(NETWORK_SEPARATOR);
	1599	}
	1600
	1601	private void saveNetworkDataStats(PrintStream outStream) {
	1602
	1603	for (NetworkData netData : receivedNetData) {
	1604	TaskInputFile tif = (TaskInputFile) netData.getData();
	1605	outStream.print(tif.getJobID());
	1606	outStream.print(NETWORK_SEPARATOR);
	1607	outStream.print(tif.getTaskID());
	1608	outStream.print(NETWORK_SEPARATOR);
	1609	outStream.print(tif.getFileName());
	1610	outStream.print(NETWORK_SEPARATOR);
	1611	outStream.print(netData.getRoute());
	1612	outStream.print(NETWORK_SEPARATOR);
	1613	outStream.print(netData.getStartTime());
	1614	outStream.print(NETWORK_SEPARATOR);
	1615	outStream.print(netData.getEndTime());
	1616	outStream.print(NETWORK_SEPARATOR);
	1617	outStream.print(netData.getReservationID());
	1618	outStream.println(NETWORK_SEPARATOR);
	1619	}
	1620	}
	1621
	1622	/*
	1623	* private void saveLinkReservationStats(LinkStats linkStats, PrintStream
	1624	* outStream) {
	1625	*
	1626	* outStream.print(linkStats.linkName);
	1627	* outStream.println(NETWORK_SEPARATOR); for (int i = 0; i <
	1628	* linkStats.reservationStats.size(); i++) { LinkStats.LinkReservationStats
	1629	* resStats = linkStats.reservationStats .get(i);
	1630	* outStream.print(resStats.reservationID);
	1631	* outStream.print(NETWORK_SEPARATOR); outStream.print(resStats.startTime);
	1632	* outStream.print(NETWORK_SEPARATOR); outStream.print(resStats.endTime);
	1633	* outStream.print(NETWORK_SEPARATOR); outStream.print(resStats.bandwidth);
	1634	* outStream.print(NETWORK_SEPARATOR);
	1635	* outStream.print(NETWORK_NUMBER_FORMAT.format(resStats.flowsSize));
	1636	* outStream.print(NETWORK_SEPARATOR);
	1637	* outStream.print(NETWORK_NUMBER_FORMAT.format(resStats.load));
	1638	* outStream.println(NETWORK_SEPARATOR); } }
	1639	*/
	1640
	1641	private boolean saveCategoryChart(JFreeChart c, String fileName,
	1642	String labelFormat) {
	1643	c.setNotify(false);
	1644	c.setAntiAlias(true);
	1645	c.setTextAntiAlias(true);
	1646	c.setBorderVisible(false);
	1647
	1648	CategoryPlot categoryplot = (CategoryPlot) c.getPlot();
	1649	categoryplot.setDomainGridlinesVisible(true);
	1650
	1651	if (labelFormat != null) {
	1652	CategoryItemRenderer rend = categoryplot.getRenderer();
	1653	rend.setBaseItemLabelsVisible(true);
	1654	ItemLabelPosition position = new ItemLabelPosition(
	1655	ItemLabelAnchor.CENTER, TextAnchor.CENTER);
	1656	rend.setBasePositiveItemLabelPosition(position);
	1657	NumberFormat nf = NumberFormat.getInstance();
	1658	CategoryItemLabelGenerator gen = new StandardCategoryItemLabelGenerator(
	1659	labelFormat, nf);
	1660	rend.setBaseItemLabelGenerator(gen);
	1661	}
	1662
	1663	int rows = c.getCategoryPlot().getDataset().getColumnKeys().size();
	1664
	1665	int height = 900;
	1666	if (rows > 45) {
	1667	height = rows * 20;
	1668	}
	1669	int width = calculateChartWidth(c);
	1670	CategoryItemRenderer rend = c.getCategoryPlot().getRenderer();
	1671
	1672	for (int i = 0; i < c.getCategoryPlot().getDataset().getRowKeys()
	1673	.size(); i++) {
	1674	Paint collor = c.getCategoryPlot().getDrawingSupplier()
	1675	.getNextPaint();
	1676	rend.setSeriesOutlinePaint(i, collor);
	1677	rend.setSeriesPaint(i, collor);
	1678	}
	1679
	1680	ChartRenderingInfo info = new ChartRenderingInfo();
	1681	// info.setEntityCollection(null);
	1682	File f = new File(fileName + "." + ImageFormat.PNG);
	1683	final String gssimSubtitle = "Created by "
	1684	+ GridSchedulingSimulator.SIMULATOR_NAME
	1685	+ " http://www.gssim.org/";
	1686	c.addSubtitle(new TextTitle(gssimSubtitle));
	1687	boolean encodeAlpha = false;
	1688	int compression = 9;
	1689	try {
	1690	ChartUtilities.saveChartAsPNG(f, c, width, height, info,
	1691	encodeAlpha, compression);
	1692
	1693	} catch (IOException e) {
	1694	e.printStackTrace();
	1695	return false;
	1696	} catch (Exception e) {
	1697	if (log.isErrorEnabled())
	1698	log
	1699	.error(
	1700	"The png file ("
	1701	+ fileName
	1702	+ ")\nwill not be generated (It can be too large data size problem)",
	1703	e);
	1704	} catch (Throwable t) {
	1705	log
	1706	.error(
	1707	"The png file ("
	1708	+ fileName
	1709	+ ")\nwill not be generated (It can be too large data size problem)",
	1710	t);
	1711	}
	1712
	1713	return true;
	1714	}
	1715
	1716	private int calculateChartWidth(JFreeChart c) {
	1717
	1718	int ganttWidth = GANTT_WIDTH;
	1719	int rows = c.getCategoryPlot().getDataset().getColumnKeys().size();
	1720
	1721	if (rows > 45) {
	1722	int height = rows * 20;
	1723	ganttWidth = Math.max((int) (height * 1.5), GANTT_WIDTH);
	1724	}
	1725	return ganttWidth;
	1726	}
	1727
	1728	private boolean saveXYPlotChart(JFreeChart c, String fileName) {
	1729	c.setNotify(false);
	1730	c.setAntiAlias(true);
	1731	c.setTextAntiAlias(true);
	1732	c.setBorderVisible(false);
	1733
	1734	int height = 900;
	1735
	1736	CombinedDomainXYPlot cPlot = (CombinedDomainXYPlot) c.getPlot();
	1737	int nPlots = cPlot.getSubplots().size();
	1738
	1739	if (nPlots > 3) {
	1740	height = nPlots * 300;
	1741	}
	1742	int width = GANTT_WIDTH;
	1743
	1744	if (configuration.creatediagrams_resources_scale != -1)
	1745	width = (int) ((endSimulationTime - startSimulationTime) * configuration.creatediagrams_resources_scale);
	1746	ChartRenderingInfo info = new ChartRenderingInfo();
	1747	File f = new File(fileName + "." + ImageFormat.PNG);
	1748	final String gssimSubtitle = "Created by "
	1749	+ GridSchedulingSimulator.SIMULATOR_NAME
	1750	+ " http://www.gssim.org/";
	1751	c.addSubtitle(new TextTitle(gssimSubtitle));
	1752	boolean encodeAlpha = false;
	1753	int compression = 9;// values 0-9
	1754	try {
	1755	ChartUtilities.saveChartAsPNG(f, c, width, height, info,
	1756	encodeAlpha, compression);
	1757	} catch (IOException e) {
	1758	e.printStackTrace();
	1759	return false;
	1760	}
	1761	return true;
	1762	}
	1763
	1764	private void createStatsData() {
	1765	statsData.put(MAKESPAN, accStats.makespan);
	1766	statsData.put(TASK_COMPLETION_TIME, accStats.meanTaskCompletionTime);
	1767	statsData.put(TASK_EXECUTION_TIME, accStats.meanTaskExecutionTime);
	1768	statsData.put(TASK_START_TIME, accStats.meanTaskStartTime);
	1769	statsData.put(TASK_FLOW_TIME, accStats.meanTaskFlowTime);
	1770	statsData.put(TASK_WAITING_TIME, accStats.meanTaskWaitingTime);
	1771	statsData.put(TASK_LATENESS, accStats.lateness);
	1772	statsData.put(TASK_TARDINESS, accStats.tardiness);
	1773	statsData.put(DELAYED_TASKS, accStats.delayedTasks);
	1774	statsData.put(FAILED_REQUESTS, accStats.failedRequests);
	1775	statsData.put(RESOURCES_TOTAL_LOAD, accStats.meanTotalLoad);
	1776	statsData.put(RESOURCES_RESERVATION_LOAD, accStats.meanReservationLoad);
	1777	statsData.put(RESOURCES_RESERVATION_LOAD, accStats.meanEnergyUsage);
	1778	statsData.put(RESOURCES_QUEUE_LENGTH, accStats.meanQueueLength);
	1779	}
	1780
	1781	public GSSAccumulator getStats(String name) {
	1782	return statsData.get(name);
	1783	}
	1784
	1785	public boolean accumulatedStats() {
	1786	return configuration.createsimulationstatistics;
	1787	}
	1788
	1789	public static class JobIdComparator implements Comparator<JobInterface<?>> {
	1790
	1791	public int compare(JobInterface<?> o1, JobInterface<?> o2) {
	1792	try {
	1793	return o1.getId().compareTo(o2.getId());
	1794	} catch (NoSuchFieldException e) {
	1795	e.printStackTrace();
	1796	}
	1797	return -1;
	1798	}
	1799	}
	1800
	1801
	1802	/*
	1803	* private void saveFormatedLinkReservationStats(LinkStats linkStats,
	1804	* PrintStream outStream) { outStream.printf("%15s", linkStats.linkName);
	1805	* outStream.println(); for (int i = 0; i <
	1806	* linkStats.reservationStats.size(); i++) { LinkStats.LinkReservationStats
	1807	* resStats = linkStats.reservationStats .get(i); outStream.printf("%15s",
	1808	* resStats.reservationID); outStream.printf("%32s", new
	1809	* DateTime(resStats.startTime)); outStream.printf("%31s", new
	1810	* DateTime(resStats.endTime)); outStream.printf("%16s",
	1811	* NETWORK_NUMBER_FORMAT .format(resStats.bandwidth));
	1812	* outStream.printf("%35s", NETWORK_NUMBER_FORMAT
	1813	* .format(resStats.flowsSize)); outStream.printf("%10s",
	1814	* NETWORK_NUMBER_FORMAT .format(resStats.load)); outStream.println(); }
	1815	* outStream.println(); }
	1816	*/
	1817	}

Note: See TracBrowser for help on using the repository browser.

Download in other formats:

Original Format