Context Navigation

← Previous Revision
Next Revision →
Normal
Revision Log

StringSerializer.java @ 805

Revision 805, 17.5 KB checked in by wojtekp, 12 years ago (diff)

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

Rev	Line
[477]	1	package simulator.stats.implementation.out;
	2
	3
	4	import java.util.Map;
	5
	6	import org.apache.commons.logging.Log;
	7	import org.apache.commons.logging.LogFactory;
	8
	9	import simulator.DataCenterWorkloadSimulator;
	10	import simulator.stats.implementation.AccumulatedResourceStats;
	11	import simulator.stats.implementation.GSSAccumulatorsStats;
	12	import simulator.stats.implementation.JobStats;
[495]	13	import simulator.stats.implementation.ResourceAirFlowStats;
[496]	14	import simulator.stats.implementation.ResourcePowerStats;
[477]	15	import simulator.stats.implementation.ResourceStats;
[805]	16	import simulator.stats.implementation.ResourceTemperatureStats;
[477]	17	import simulator.stats.implementation.ResourceUsageStats;
	18	import simulator.stats.implementation.TaskStats;
	19
	20	/**
	21	*
	22	* @author Marcin Krystek, Jarek Szymczak
	23	*
	24	*/
	25	public class StringSerializer extends AbstractStringSerializer {
	26
	27	private Log log = LogFactory.getLog(StringSerializer.class);
	28
	29	public String visit(TaskStats taskStats) {
	30	StringBuffer buffer = null;
	31
	32	if(printedHeaders.add("taskStats")) {
	33	buffer = new StringBuffer(520);
	34	String[] headers = taskStats.getHeaders();
	35	if (headers.length >= 10) {
	36
	37	for(int i = 0; i < 10; i++)
	38	{
	39	buffer.append(headers[i]);
	40	buffer.append(fieldSeparator);
	41	}
	42
	43	if (this.useExtended) {
	44
	45	for(int i = 10; i < headers.length; i++)
	46	{
	47	buffer.append(headers[i]);
	48	buffer.append(fieldSeparator);
	49	}
	50
	51	}
	52
	53	} else {
	54	buffer.append(headers.toString());
	55	}
	56	buffer.append(System.getProperty("line.separator"));
	57	} else {
	58	buffer = new StringBuffer(260);
	59	}
	60
	61	buffer.append(taskStats.getJobID());
	62	buffer.append(fieldSeparator);
	63	buffer.append(taskStats.getTaskID());
	64	buffer.append(fieldSeparator);
	65	buffer.append(taskStats.getUserDN());
	66	buffer.append(fieldSeparator);
	67	buffer.append(taskStats.getResName());
	68	buffer.append(fieldSeparator);
	69	buffer.append(taskStats.getCpuCnt());
	70	buffer.append(fieldSeparator);
	71	buffer.append(Double.valueOf(taskStats.getExecStartDate()).longValue());
	72	buffer.append(fieldSeparator);
	73	buffer.append(Double.valueOf(taskStats.getExecFinishDate()).longValue());
	74	buffer.append(fieldSeparator);
	75	buffer.append(Double.valueOf(taskStats.getExecEndDate()).longValue());
	76	buffer.append(fieldSeparator);
	77	buffer.append(Double.valueOf(taskStats.getGB_SubDate()).longValue());
	78	buffer.append(fieldSeparator);
	79	buffer.append(Double.valueOf(taskStats.getLB_SubDate()).longValue());
	80	buffer.append(fieldSeparator);
	81	if (this.useExtended) {
	82	buffer.append(Double.valueOf(taskStats.getCompletionTime())
	83	.longValue());
	84	buffer.append(fieldSeparator);
	85	buffer.append(Double.valueOf(taskStats.getExecStartTime()).longValue());
	86	buffer.append(fieldSeparator);
	87	buffer.append(Double.valueOf(taskStats.getExecutionTime()).longValue());
	88	buffer.append(fieldSeparator);
	89	buffer.append(Double.valueOf(taskStats.getReadyTime()).longValue());
	90	buffer.append(fieldSeparator);
	91	buffer.append(Double.valueOf(taskStats.getStartTime()).longValue());
	92	buffer.append(fieldSeparator);
	93	buffer.append(Double.valueOf(taskStats.getFlowTime()).longValue());
	94	buffer.append(fieldSeparator);
	95	buffer.append(Double.valueOf(taskStats.getWaitingTime()).longValue());
	96	buffer.append(fieldSeparator);
	97	buffer.append(Double.valueOf(taskStats.getGQ_WaitingTime())
	98	.longValue());
	99	buffer.append(fieldSeparator);
	100	buffer.append(Double.valueOf(taskStats.getLateness()).longValue());
	101	buffer.append(fieldSeparator);
	102	buffer.append(Double.valueOf(taskStats.getTardiness()).longValue());
	103	buffer.append(fieldSeparator);
	104	buffer.append(Double.valueOf(taskStats.getReservationStartDate())
	105	.longValue());
	106	buffer.append(fieldSeparator);
	107	buffer.append(Double.valueOf(taskStats.getReservationFinishDate())
	108	.longValue());
	109	buffer.append(fieldSeparator);
	110	buffer.append(taskStats.getProcessorsName());
	111	buffer.append(fieldSeparator);
	112	}
	113
	114
	115	return buffer.toString();
	116	}
	117
	118	public String visit(JobStats jobStats) {
	119
	120	StringBuffer buffer = null;
	121
	122	if(printedHeaders.add("jobStats")) {
	123	buffer = new StringBuffer(200);
	124	String[] headers = jobStats.getHeaders();
	125	for(int i = 0; i < headers.length; i++)
	126	{
	127	buffer.append(headers[i]);
	128	buffer.append(fieldSeparator);
	129	}
	130	buffer.append(System.getProperty("line.separator"));
	131	} else {
	132	buffer = new StringBuffer(100);
	133	}
	134
	135	buffer.append(jobStats.getJobID());
	136	buffer.append(fieldSeparator);
	137	buffer.append(defaultNumberFormat
	138	.format(jobStats.getMeanTaskCompletionTime().getMean()));
	139	buffer.append(fieldSeparator);
	140	buffer.append(defaultNumberFormat
	141	.format(jobStats.getMeanTaskExecutionTime().getMean()));
	142	buffer.append(fieldSeparator);
	143	buffer.append(defaultNumberFormat
	144	.format(jobStats.getMeanTaskStartTime().getMean()));
	145	buffer.append(fieldSeparator);
	146	buffer.append(defaultNumberFormat
	147	.format(jobStats.getMeanTaskFlowTime().getMean()));
	148	buffer.append(fieldSeparator);
	149	buffer.append(defaultNumberFormat
	150	.format(jobStats.getMeanTaskWaitingTime().getMean()));
	151	buffer.append(fieldSeparator);
	152	buffer.append(defaultNumberFormat
	153	.format(jobStats.getMeanTaskGQ_WaitingTime().getMean()));
	154	buffer.append(fieldSeparator);
	155	buffer.append(defaultNumberFormat
	156	.format(jobStats.getTardiness().getMean()));
	157	buffer.append(fieldSeparator);
	158	buffer.append(defaultNumberFormat
	159	.format(jobStats.getLateness().getMean()));
	160	buffer.append(fieldSeparator);
	161	buffer.append(defaultNumberFormat
	162	.format(jobStats.getMakespan().getMean()));
	163	buffer.append(fieldSeparator);
	164
	165	return buffer.toString();
	166	}
	167
	168	public String visit(ResourceStats resourceStats){
	169
	170	StringBuffer buffer = null;
	171
	172	if(printedHeaders.add("resourceStats")) {
	173	buffer = new StringBuffer(600);
	174	String[] headers = resourceStats.getHeaders();
	175	for(int i = 0; i < headers.length; i++)
	176	{
	177	buffer.append(headers[i]);
	178	buffer.append(fieldSeparator);
	179	}
	180	buffer.append(System.getProperty("line.separator"));
	181	} else {
	182	buffer = new StringBuffer(300);
	183	}
	184
	185	buffer.append(resourceStats.getResourceName());
	186	buffer.append(fieldSeparator);
	187
	188	buffer.append(resourceStats.getMemory());
	189	buffer.append(fieldSeparator);
	190
	191	buffer.append(resourceStats.getCpucnt());
	192	buffer.append(fieldSeparator);
	193
	194	buffer.append(resourceStats.getCpuspeed());
	195	buffer.append(fieldSeparator);
	196
	197	buffer.append(DataCenterWorkloadSimulator.DFAULT_NUMBER_FORMAT
	198	.format(resourceStats.getQueueLength()));
	199	buffer.append(fieldSeparator);
	200
	201	/*Map<String, Double> processorsLoad = resourceStats.getProcessorsLoad();
	202	for (String processorName : processorsLoad.keySet()) {
	203
	204	Double load = processorsLoad.get(processorName);
	205	buffer.append(processorName);
	206	buffer.append(" ");
	207	buffer.append(GridSchedulingSimulator.DFAULT_NUMBER_FORMAT
	208	.format(load));
	209	buffer.append(":");
	210
	211	}*/
	212
	213	buffer.append(fieldSeparator);
	214	Map<String, Double> processorsReservationLoad = resourceStats
	215	.getProcessorsReservationLoad();
	216	for (String processorName : processorsReservationLoad.keySet()) {
	217
	218	Double reservationLoad = processorsReservationLoad
	219	.get(processorName);
	220	buffer.append(processorName);
	221	buffer.append(" ");
	222	buffer.append(DataCenterWorkloadSimulator.DFAULT_NUMBER_FORMAT
	223	.format(reservationLoad));
	224	buffer.append(":");
	225	}
	226	buffer.append(fieldSeparator);
	227	return buffer.toString();
	228	}
	229
	230	public String visit(AccumulatedResourceStats accResStats){
	231
	232	StringBuffer buffer = null;
	233
	234	if(printedHeaders.add("accResStats")) {
	235	buffer = new StringBuffer(340);
	236	String[] headers = accResStats.getHeaders();
	237	for(int i = 0; i < headers.length; i++)
	238	{
	239	buffer.append(headers[i]);
	240	buffer.append(fieldSeparator);
	241	}
	242	buffer.append(System.getProperty("line.separator"));
	243	} else {
	244	buffer = new StringBuffer(170);
	245	}
	246
	247	buffer.append(accResStats.getResourceName());
	248	buffer.append(fieldSeparator);
	249	buffer.append("load");
	250	buffer.append(accResStats.getResourceLoad().toString());
	251	buffer.append(System.getProperty("line.separator"));
	252	buffer.append(accResStats.getResourceName());
	253	buffer.append(fieldSeparator);
	254	buffer.append("reservationload");
	255	buffer.append(accResStats.getResourceReservationLoad().toString());
	256	buffer.append(System.getProperty("line.separator"));
	257
	258	return buffer.toString();
	259	}
	260
	261	public Object visit(ResourceUsageStats resourceUsageStats) {
[496]	262	Map<Long, Double> resourceUsage = resourceUsageStats.getHistory();
[477]	263
	264	int mapSize = resourceUsage.size();
	265	/*
	266	* FIXME:
	267	* Integer.MAX_VALUE = 2147483647. We assume, that each line contains
	268	* max 30 signs - this gives max 71582788 lines. If resourceUsage map
	269	* contains more elements then we have a problem, because content of
	270	* resourceUsage map will not fit in the buffer.
	271	* This will need further attention in the future.
	272	*/
	273	int maxSize = (Integer.MAX_VALUE / 30 ) - 1;
	274	if(mapSize >= maxSize){
	275	log.error("Resource usage data is to long to fit in the buffer.");
	276	return null;
	277	}
	278
	279	int size = 30 * resourceUsage.size();
	280
	281	StringBuffer buffer = null;
	282
	283	if(printedHeaders.add(resourceUsageStats.getUsageType())) {
	284	buffer = new StringBuffer(size + 42);
	285	String[] headers = resourceUsageStats.getHeaders();
	286	for(int i = 0; i < headers.length; i++)
	287	{
	288	buffer.append(headers[i]);
	289	buffer.append(fieldSeparator);
	290	}
	291	buffer.append(System.getProperty("line.separator"));
	292	} else {
	293	buffer = new StringBuffer(size);
	294	}
	295
	296
	297	for (Long timestamp : resourceUsage.keySet()) {
	298
	299	buffer.append(resourceUsageStats.getResourceName());
	300	buffer.append(fieldSeparator);
[495]	301	Double value = resourceUsage.get(timestamp);
[477]	302	buffer.append(timestamp);
	303	buffer.append(fieldSeparator);
	304	buffer.append(DataCenterWorkloadSimulator.DFAULT_NUMBER_FORMAT
	305	.format(value));
	306	buffer.append(fieldSeparator);
	307	buffer.append(System.getProperty("line.separator"));
	308
	309	}
	310	if(resourceUsage.size() > 0){
[496]	311	buffer.append("mean: " + resourceUsageStats.getMeanValue());
[477]	312	buffer.append(System.getProperty("line.separator"));
	313	}
	314	return buffer.toString();
	315	}
	316
[496]	317	public Object visit(ResourcePowerStats resourceEnergyStats) {
	318	Map<Long, Double> resourceEnergy = resourceEnergyStats.getHistory();
[477]	319
	320	int mapSize = resourceEnergy.size();
	321	/*
	322	* FIXME:
	323	* Integer.MAX_VALUE = 2147483647. We assume, that each line contains
	324	* max 30 signs - this gives max 71582788 lines. If resourceUsage map
	325	* contains more elements then we have a problem, because content of
	326	* resourceUsage map will not fit in the buffer.
	327	* This will need further attention in the future.
	328	*/
	329	int maxSize = (Integer.MAX_VALUE / 30 ) - 1;
	330	if(mapSize >= maxSize){
	331	log.error("Resource usage data is to long to fit in the buffer.");
	332	return null;
	333	}
	334
	335	int size = 30 * resourceEnergy.size();
	336
	337	StringBuffer buffer = null;
	338
	339	if(printedHeaders.add(resourceEnergyStats.getUsageType())) {
	340	buffer = new StringBuffer(size + 42);
	341	String[] headers = resourceEnergyStats.getHeaders();
	342	for(int i = 0; i < headers.length; i++)
	343	{
	344	buffer.append(headers[i]);
	345	buffer.append(fieldSeparator);
	346	}
	347	buffer.append(System.getProperty("line.separator"));
	348	} else {
	349	buffer = new StringBuffer(size);
	350	}
	351
	352
	353	for (Long timestamp : resourceEnergy.keySet()) {
	354
	355	buffer.append(resourceEnergyStats.getResourceName());
	356	buffer.append(fieldSeparator);
	357	Double value = resourceEnergy.get(timestamp);
	358	buffer.append(timestamp);
	359	buffer.append(fieldSeparator);
	360	buffer.append(DataCenterWorkloadSimulator.DFAULT_NUMBER_FORMAT
	361	.format(value));
	362	buffer.append(fieldSeparator);
	363	buffer.append(System.getProperty("line.separator"));
	364
	365	}
	366
	367	if(resourceEnergy.size() > 0) {
[496]	368	buffer.append("mean: "+resourceEnergyStats.getMeanValue() + " sum: " +resourceEnergyStats.getSumValue());
[477]	369	buffer.append(System.getProperty("line.separator"));
	370	}
	371
	372	return buffer.toString();
	373	}
	374
[495]	375	public Object visit(ResourceAirFlowStats resourceAirFlowStats) {
[496]	376	Map<Long, Double> resourceAirFlow = resourceAirFlowStats.getHistory();
[495]	377
	378	int mapSize = resourceAirFlow.size();
	379	/*
	380	* FIXME:
	381	* Integer.MAX_VALUE = 2147483647. We assume, that each line contains
	382	* max 30 signs - this gives max 71582788 lines. If resourceUsage map
	383	* contains more elements then we have a problem, because content of
	384	* resourceUsage map will not fit in the buffer.
	385	* This will need further attention in the future.
	386	*/
	387	int maxSize = (Integer.MAX_VALUE / 30 ) - 1;
	388	if(mapSize >= maxSize){
	389	log.error("Resource usage data is to long to fit in the buffer.");
	390	return null;
	391	}
	392
	393	int size = 30 * resourceAirFlow.size();
	394
	395	StringBuffer buffer = null;
	396
	397	if(printedHeaders.add(resourceAirFlowStats.getUsageType())) {
	398	buffer = new StringBuffer(size + 42);
	399	String[] headers = resourceAirFlowStats.getHeaders();
	400	for(int i = 0; i < headers.length; i++)
	401	{
	402	buffer.append(headers[i]);
	403	buffer.append(fieldSeparator);
	404	}
	405	buffer.append(System.getProperty("line.separator"));
	406	} else {
	407	buffer = new StringBuffer(size);
	408	}
	409
	410
	411	for (Long timestamp : resourceAirFlow.keySet()) {
	412
	413	buffer.append(resourceAirFlowStats.getResourceName());
	414	buffer.append(fieldSeparator);
	415	Double value = resourceAirFlow.get(timestamp);
	416	buffer.append(timestamp);
	417	buffer.append(fieldSeparator);
	418	buffer.append(DataCenterWorkloadSimulator.DFAULT_NUMBER_FORMAT
	419	.format(value));
	420	buffer.append(fieldSeparator);
	421	buffer.append(System.getProperty("line.separator"));
	422
	423	}
	424
	425	if(resourceAirFlow.size() > 0) {
[496]	426	buffer.append("mean: "+resourceAirFlowStats.getMeanValue() + " sum: " +resourceAirFlowStats.getSumValue());
[495]	427	buffer.append(System.getProperty("line.separator"));
	428	}
	429
	430	return buffer.toString();
	431	}
[805]	432
	433	public Object visit(ResourceTemperatureStats resourceTemperatureStats) {
	434	Map<Long, Double> resourceTemperature = resourceTemperatureStats.getHistory();
	435
	436	int mapSize = resourceTemperature.size();
	437	/*
	438	* FIXME:
	439	* Integer.MAX_VALUE = 2147483647. We assume, that each line contains
	440	* max 30 signs - this gives max 71582788 lines. If resourceUsage map
	441	* contains more elements then we have a problem, because content of
	442	* resourceUsage map will not fit in the buffer.
	443	* This will need further attention in the future.
	444	*/
	445	int maxSize = (Integer.MAX_VALUE / 30 ) - 1;
	446	if(mapSize >= maxSize){
	447	log.error("Resource temperature data is to long to fit in the buffer.");
	448	return null;
	449	}
	450
	451	int size = 30 * resourceTemperature.size();
	452
	453	StringBuffer buffer = null;
[495]	454
[805]	455	if(printedHeaders.add(resourceTemperatureStats.getUsageType())) {
	456	buffer = new StringBuffer(size + 42);
	457	String[] headers = resourceTemperatureStats.getHeaders();
	458	for(int i = 0; i < headers.length; i++)
	459	{
	460	buffer.append(headers[i]);
	461	buffer.append(fieldSeparator);
	462	}
	463	buffer.append(System.getProperty("line.separator"));
	464	} else {
	465	buffer = new StringBuffer(size);
	466	}
	467
	468
	469	for (Long timestamp : resourceTemperature.keySet()) {
	470
	471	buffer.append(resourceTemperatureStats.getResourceName());
	472	buffer.append(fieldSeparator);
	473	Double value = resourceTemperature.get(timestamp);
	474	buffer.append(timestamp);
	475	buffer.append(fieldSeparator);
	476	buffer.append(DataCenterWorkloadSimulator.DFAULT_NUMBER_FORMAT
	477	.format(value));
	478	buffer.append(fieldSeparator);
	479	buffer.append(System.getProperty("line.separator"));
	480
	481	}
	482
	483	if(resourceTemperature.size() > 0) {
	484	buffer.append("mean: "+resourceTemperatureStats.getMeanValue() + " sum: " +resourceTemperatureStats.getSumValue());
	485	buffer.append(System.getProperty("line.separator"));
	486	}
	487
	488	return buffer.toString();
	489	}
	490
	491
[477]	492	public Object visit(GSSAccumulatorsStats accStats) {
	493
	494	StringBuffer buffer = null;
	495
	496	if(printedHeaders.add("accStats")) {
	497	buffer = new StringBuffer(2800);
	498	String[] headers = accStats.getHeaders();
	499	for(int i = 0; i < headers.length; i++)
	500	{
	501	buffer.append(headers[i]);
	502	buffer.append(fieldSeparator);
	503	}
	504	buffer.append(System.getProperty("line.separator"));
	505	} else {
	506	buffer = new StringBuffer(1400);
	507	}
	508
	509	buffer.append("Delayed tasks");
	510	buffer.append(accStats.delayedTasks);
	511	buffer.append(System.getProperty("line.separator"));
	512	buffer.append("Failed requests (tasks)");
	513	buffer.append(accStats.failedRequests);
	514	buffer.append(System.getProperty("line.separator"));
	515	buffer.append("Makespan");
	516	buffer.append(accStats.makespan);
	517	buffer.append(System.getProperty("line.separator"));
	518	buffer.append("Resources queue length");
	519	buffer.append(accStats.meanQueueLength);
	520	buffer.append(System.getProperty("line.separator"));
	521	buffer.append("Resources total load");
	522	buffer.append(accStats.meanTotalLoad);
	523	buffer.append(System.getProperty("line.separator"));
	524	buffer.append("Energy usage");
	525	buffer.append(accStats.meanEnergyUsage);
	526	buffer.append(System.getProperty("line.separator"));
	527	buffer.append("Task completion time");
	528	buffer.append(accStats.meanTaskCompletionTime);
	529	buffer.append(System.getProperty("line.separator"));
	530	buffer.append("Task execution time");
	531	buffer.append(accStats.meanTaskExecutionTime);
	532	buffer.append(System.getProperty("line.separator"));
	533	buffer.append("Task start time");
	534	buffer.append(accStats.meanTaskStartTime);
	535	buffer.append(System.getProperty("line.separator"));
	536	buffer.append("Task flow time");
	537	buffer.append(accStats.meanTaskFlowTime);
	538	buffer.append(System.getProperty("line.separator"));
	539	buffer.append("Task waiting time");
	540	buffer.append(accStats.meanTaskWaitingTime);
	541	buffer.append(System.getProperty("line.separator"));
	542	buffer.append("Task lateness");
	543	buffer.append(accStats.lateness);
	544	buffer.append(System.getProperty("line.separator"));
	545	buffer.append("Task tardiness");
	546	buffer.append(accStats.tardiness);
	547
	548	return buffer.toString();
	549	}
	550
	551	}

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

Download in other formats:

Original Format