[lttv.git] / lttv / lttv / sync / event_processing_text.c

/* This file is part of the Linux Trace Toolkit viewer
 * Copyright (C) 2009, 2010 Benjamin Poirier <benjamin.poirier@polymtl.ca>
 *
 * This program is free software: you can redistribute it and/or modify it
 * under the terms of the GNU Lesser General Public License as published by
 * the Free Software Foundation, either version 2.1 of the License, or (at
 * your option) any later version.
 *
 * This program is distributed in the hope that it will be useful, but WITHOUT
 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
 * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU Lesser General Public
 * License for more details.
 *
 * You should have received a copy of the GNU Lesser General Public License
 * along with this program.  If not, see <http://www.gnu.org/licenses/>.
 */

#define _GNU_SOURCE
#define NANOSECONDS_PER_SECOND 1000000000
#define CPU_FREQ 1e9

#ifdef HAVE_CONFIG_H
#include <config.h>
#endif

#include <errno.h>
#include <math.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>

#include "sync_chain.h"

#include "event_processing_text.h"


// Functions common to all processing modules
static void initProcessingText(SyncState* const syncState, ...);
static void destroyProcessingText(SyncState* const syncState);
static AllFactors* finalizeProcessingText(SyncState* const syncState);
static void writeProcessingTraceTimeOptionsText(SyncState* const syncState,
	const unsigned int i, const unsigned int j);
static void writeProcessingTraceTraceOptionsText(SyncState* const syncState,
	const unsigned int i, const unsigned int j);
static void writeProcessingGraphVariablesText(SyncState* const syncState,
	const unsigned int i);

// Functions specific to this module
static unsigned int readTraceNb(FILE* testCase);
static void skipCommentLines(FILE* testCase);


static ProcessingModule processingModuleText = {
	.name= "text",
	.initProcessing= &initProcessingText,
	.destroyProcessing= &destroyProcessingText,
	.finalizeProcessing= &finalizeProcessingText,
	.graphFunctions= {
		.writeVariables= &writeProcessingGraphVariablesText,
		.writeTraceTraceOptions= &writeProcessingTraceTraceOptionsText,
		.writeTraceTimeOptions= &writeProcessingTraceTimeOptionsText,
	},
};


/*
 * Processing Module registering function
 */
void registerProcessingText()
{
	g_queue_push_tail(&processingModules, &processingModuleText);
}


/*
 * Allocate and initialize data structures for synchronizing a traceset.
 * Open test case file.
 *
 * Args:
 *   syncState:    container for synchronization data.
 *   testCaseName: const char*, test case file name
 */
static void initProcessingText(SyncState* const syncState, ...)
{
	ProcessingDataText* processingData;
	const char* testCaseName;
	va_list ap;

	processingData= malloc(sizeof(ProcessingDataText));
	syncState->processingData= processingData;
	va_start(ap, syncState);
	testCaseName= va_arg(ap, const char*);
	va_end(ap);

	processingData->testCase= fopen(testCaseName, "r");
	if (processingData->testCase == NULL)
	{
		g_error(strerror(errno));
	}
	syncState->traceNb= readTraceNb(processingData->testCase);

	if (syncState->stats)
	{
		processingData->factors= NULL;
	}
}


static void destroyProcessingText(SyncState* const syncState)
{
	ProcessingDataText* processingData= (ProcessingDataText*)
		syncState->processingData;

	if (processingData == NULL)
	{
		return;
	}

	fclose(processingData->testCase);

	if (syncState->stats && processingData->factors)
	{
		freeAllFactors(processingData->factors);
	}

	free(syncState->processingData);
	syncState->processingData= NULL;
}


/*
 * Read the test case file and make up events. Dispatch those events to the
 * matching module.
 *
 * Args:
 *   syncState:    container for synchronization data.
 *
 * Returns:
 *   AllFactors    synchronization factors for each trace pair
 */
static AllFactors* finalizeProcessingText(SyncState* const syncState)
{
	int retval;
	unsigned int* seq;
	AllFactors* factors;
	ProcessingDataText* processingData= (ProcessingDataText*)
		syncState->processingData;
	FILE* testCase= processingData->testCase;
	char* line= NULL;
	size_t bufLen;

	seq= calloc(syncState->traceNb, sizeof(unsigned int));

	skipCommentLines(testCase);
	retval= getline(&line, &bufLen, testCase);
	while(!feof(testCase))
	{
		unsigned int sender, receiver;
		double sendTime, recvTime;
		char tmp;
		unsigned int i;

		if (retval == -1 && !feof(testCase))
		{
			g_error(strerror(errno));
		}

		if (line[retval - 1] == '\n')
		{
			line[retval - 1]= '\0';
		}

		retval= sscanf(line, " %u %u %lf %lf %c", &sender, &receiver,
			&sendTime, &recvTime, &tmp);
		if (retval == EOF)
		{
			g_error(strerror(errno));
		}
		else if (retval != 4)
		{
			g_error("Error parsing test file while looking for data point, line was '%s'", line);
		}

		if (sender + 1 > syncState->traceNb)
		{
			g_error("Error parsing test file, sender is out of range, line was '%s'", line);
		}

		if (receiver + 1 > syncState->traceNb)
		{
			g_error("Error parsing test file, receiver is out of range, line was '%s'", line);
		}

		if (sendTime < 0)
		{
			g_error("Error parsing test file, send time is negative, line was '%s'", line);
		}

		if (recvTime < 0)
		{
			g_error("Error parsing test file, receive time is negative, line was '%s'", line);
		}

		// Generate ouput and input events
		{
			unsigned int addressOffset;
			struct {
				unsigned int traceNum;
				double time;
				enum Direction direction;
			} loopValues[]= {
				{sender, sendTime, OUT},
				{receiver, recvTime, IN},
			};

			/* addressOffset is added to a traceNum to convert it to an address so
			 * that the address is not plainly the same as the traceNb. */
			if (syncState->traceNb > 1)
			{
				addressOffset= pow(10, floor(log(syncState->traceNb - 1) /
						log(10)) + 1);
			}
			else
			{
				addressOffset= 0;
			}

			for (i= 0; i < sizeof(loopValues) / sizeof(*loopValues); i++)
			{
				Event* event;

				event= malloc(sizeof(Event));
				event->traceNum= loopValues[i].traceNum;
				event->wallTime.seconds= floor(loopValues[i].time);
				event->wallTime.nanosec= floor((loopValues[i].time -
						floor(loopValues[i].time)) * NANOSECONDS_PER_SECOND);
				event->cpuTime= round(loopValues[i].time * CPU_FREQ);
				event->type= TCP;
				event->destroy= &destroyTCPEvent;
				event->event.tcpEvent= malloc(sizeof(TCPEvent));
				event->event.tcpEvent->direction= loopValues[i].direction;
				event->event.tcpEvent->segmentKey= malloc(sizeof(SegmentKey));
				event->event.tcpEvent->segmentKey->ihl= 5;
				event->event.tcpEvent->segmentKey->tot_len= 40;
				event->event.tcpEvent->segmentKey->connectionKey.saddr= sender +
					addressOffset;
				event->event.tcpEvent->segmentKey->connectionKey.daddr= receiver +
					addressOffset;
				event->event.tcpEvent->segmentKey->connectionKey.source= 57645;
				event->event.tcpEvent->segmentKey->connectionKey.dest= 80;
				event->event.tcpEvent->segmentKey->seq= seq[sender];
				event->event.tcpEvent->segmentKey->ack_seq= 0;
				event->event.tcpEvent->segmentKey->doff= 5;
				event->event.tcpEvent->segmentKey->ack= 0;
				event->event.tcpEvent->segmentKey->rst= 0;
				event->event.tcpEvent->segmentKey->syn= 1;
				event->event.tcpEvent->segmentKey->fin= 0;

				syncState->matchingModule->matchEvent(syncState, event);
			}
		}

		seq[sender]++;

		skipCommentLines(testCase);
		retval= getline(&line, &bufLen, testCase);
	}

	free(seq);

	if (line)
	{
		free(line);
	}

	factors= syncState->matchingModule->finalizeMatching(syncState);
	if (syncState->stats)
	{
		processingData->factors= factors;
	}

	return factors;
}


/*
 * Read trace number from the test case stream. The trace number should be the
 * first non-comment line and should be an unsigned int by itself on a line.
 *
 * Args:
 *   testCase:     test case stream
 *
 * Returns:
 *   The trace number
 */
static unsigned int readTraceNb(FILE* testCase)
{
	unsigned int result;
	int retval;
	char* line= NULL;
	size_t len;
	char tmp;

	skipCommentLines(testCase);
	retval= getline(&line, &len, testCase);
	if (retval == -1)
	{
		if (feof(testCase))
		{
			g_error("Unexpected end of file while looking for number of traces");
		}
		else
		{
			g_error(strerror(errno));
		}
	}
	if (line[retval - 1] == '\n')
	{
		line[retval - 1]= '\0';
	}

	retval= sscanf(line, " %u %c", &result, &tmp);
	if (retval == EOF || retval != 1)
	{
		g_error("Error parsing test file while looking for number of traces, line was '%s'", line);

		// Not really needed but avoids warning from gcc
		abort();
	}

	if (line)
	{
		free(line);
	}

	return result;
}


/*
 * Advance testCase stream over empty space, empty lines and lines that begin
 * with '#'
 *
 * Args:
 *   testCase:     test case stream
 */
static void skipCommentLines(FILE* testCase)
{
	int firstChar;
	ssize_t retval;
	char* line= NULL;
	size_t len;

	do
	{
		firstChar= fgetc(testCase);
		if (firstChar == (int) '#')
		{
			retval= getline(&line, &len, testCase);
			if (retval == -1)
			{
				if (feof(testCase))
				{
					goto outEof;
				}
				else
				{
					g_error(strerror(errno));
				}
			}
		}
		else if (firstChar == (int) '\n' || firstChar == (int) ' ')
		{}
		else if (firstChar == EOF)
		{
			goto outEof;
		}
		else
		{
			break;
		}
	} while (true);
	retval= ungetc(firstChar, testCase);
	if (retval == EOF)
	{
		g_error("Error: ungetc()");
	}

outEof:
	if (line)
	{
		free(line);
	}
}


/*
 * Write the processing-specific variables in the gnuplot script.
 *
 * Args:
 *   syncState:    container for synchronization data
 *   i:            trace number
 */
static void writeProcessingGraphVariablesText(SyncState* const syncState,
	const unsigned int i)
{
	fprintf(syncState->graphsStream, "clock_freq_%u= %.3f\n", i, CPU_FREQ);
}


/*
 * Write the processing-specific options in the gnuplot script.
 *
 * Args:
 *   syncState:    container for synchronization data
 *   i:            first trace number
 *   j:            second trace number, garanteed to be larger than i
 */
static void writeProcessingTraceTraceOptionsText(SyncState* const syncState,
	const unsigned int i, const unsigned int j)
{
	fprintf(syncState->graphsStream,
        "set key inside right bottom\n"
        "set xlabel \"Clock %1$u\"\n"
        "set xtics nomirror\n"
        "set ylabel \"Clock %2$u\"\n"
        "set ytics nomirror\n"
		"set x2label \"Clock %1$d (s)\"\n"
		"set x2range [GPVAL_X_MIN / clock_freq_%1$u : GPVAL_X_MAX / clock_freq_%1$u]\n"
		"set x2tics\n"
		"set y2label \"Clock %2$d (s)\"\n"
		"set y2range [GPVAL_Y_MIN / clock_freq_%2$u : GPVAL_Y_MAX / clock_freq_%2$u]\n"
		"set y2tics\n", i, j);
}


/*
 * Write the processing-specific options in the gnuplot script.
 *
 * Args:
 *   syncState:    container for synchronization data
 *   i:            first trace number
 *   j:            second trace number, garanteed to be larger than i
 */
static void writeProcessingTraceTimeOptionsText(SyncState* const syncState,
	const unsigned int i, const unsigned int j)
{
	fprintf(syncState->graphsStream,
        "set key inside right bottom\n"
        "set xlabel \"Clock %1$u\"\n"
        "set xtics nomirror\n"
        "set ylabel \"time (s)\"\n"
        "set ytics nomirror\n"
		"set x2label \"Clock %1$d (s)\"\n"
		"set x2range [GPVAL_X_MIN / clock_freq_%1$u : GPVAL_X_MAX / clock_freq_%1$u]\n"
		"set x2tics\n", i);
}
Commit	Line	Data
48b641c1	1	/* This file is part of the Linux Trace Toolkit viewer
277e5b53	2	* Copyright (C) 2009, 2010 Benjamin Poirier <benjamin.poirier@polymtl.ca>
48b641c1	3	*
277e5b53 BP	4	* This program is free software: you can redistribute it and/or modify it
	5	* under the terms of the GNU Lesser General Public License as published by
	6	* the Free Software Foundation, either version 2.1 of the License, or (at
	7	* your option) any later version.
48b641c1	8	*
277e5b53 BP	9	* This program is distributed in the hope that it will be useful, but WITHOUT
	10	* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
	11	* FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public
	12	* License for more details.
48b641c1	13	*
277e5b53 BP	14	* You should have received a copy of the GNU Lesser General Public License
277e5b53 BP	15	* along with this program. If not, see <http://www.gnu.org/licenses/>.
48b641c1 BP	16	*/
48b641c1 BP	17
6ce8ceac	18	#define _GNU_SOURCE
48b641c1 BP	19	#define NANOSECONDS_PER_SECOND 1000000000
	20	#define CPU_FREQ 1e9
	21
	22	#ifdef HAVE_CONFIG_H
	23	#include <config.h>
	24	#endif
	25
	26	#include <errno.h>
	27	#include <math.h>
	28	#include <stdio.h>
	29	#include <stdlib.h>
	30	#include <string.h>
	31
	32	#include "sync_chain.h"
	33
	34	#include "event_processing_text.h"
	35
	36
	37	// Functions common to all processing modules
	38	static void initProcessingText(SyncState* const syncState, ...);
	39	static void destroyProcessingText(SyncState* const syncState);
0a87ec9a	40	static AllFactors* finalizeProcessingText(SyncState* const syncState);
48b641c1 BP	41	static void writeProcessingTraceTimeOptionsText(SyncState* const syncState,
	42	const unsigned int i, const unsigned int j);
	43	static void writeProcessingTraceTraceOptionsText(SyncState* const syncState,
	44	const unsigned int i, const unsigned int j);
	45	static void writeProcessingGraphVariablesText(SyncState* const syncState,
	46	const unsigned int i);
	47
	48	// Functions specific to this module
48b641c1 BP	49	static unsigned int readTraceNb(FILE* testCase);
	50	static void skipCommentLines(FILE* testCase);
	51
	52
	53	static ProcessingModule processingModuleText = {
	54	.name= "text",
	55	.initProcessing= &initProcessingText,
	56	.destroyProcessing= &destroyProcessingText,
	57	.finalizeProcessing= &finalizeProcessingText,
48b641c1 BP	58	.graphFunctions= {
	59	.writeVariables= &writeProcessingGraphVariablesText,
	60	.writeTraceTraceOptions= &writeProcessingTraceTraceOptionsText,
	61	.writeTraceTimeOptions= &writeProcessingTraceTimeOptionsText,
	62	},
	63	};
	64
	65
	66	/*
	67	* Processing Module registering function
	68	*/
2f961b65	69	void registerProcessingText()
48b641c1 BP	70	{
	71	g_queue_push_tail(&processingModules, &processingModuleText);
	72	}
	73
	74
	75	/*
	76	* Allocate and initialize data structures for synchronizing a traceset.
	77	* Open test case file.
	78	*
	79	* Args:
	80	* syncState: container for synchronization data.
	81	* testCaseName: const char*, test case file name
	82	*/
	83	static void initProcessingText(SyncState* const syncState, ...)
	84	{
	85	ProcessingDataText* processingData;
	86	const char* testCaseName;
	87	va_list ap;
	88
	89	processingData= malloc(sizeof(ProcessingDataText));
	90	syncState->processingData= processingData;
	91	va_start(ap, syncState);
	92	testCaseName= va_arg(ap, const char*);
	93	va_end(ap);
	94
	95	processingData->testCase= fopen(testCaseName, "r");
	96	if (processingData->testCase == NULL)
	97	{
	98	g_error(strerror(errno));
	99	}
	100	syncState->traceNb= readTraceNb(processingData->testCase);
	101
	102	if (syncState->stats)
	103	{
	104	processingData->factors= NULL;
	105	}
	106	}
	107
	108
	109	static void destroyProcessingText(SyncState* const syncState)
	110	{
	111	ProcessingDataText* processingData= (ProcessingDataText*)
	112	syncState->processingData;
	113
	114	if (processingData == NULL)
	115	{
	116	return;
	117	}
	118
6ce8ceac BP	119	fclose(processingData->testCase);
6ce8ceac BP	120
48b641c1 BP	121	if (syncState->stats && processingData->factors)
48b641c1 BP	122	{
0a87ec9a	123	freeAllFactors(processingData->factors);
48b641c1 BP	124	}
	125
	126	free(syncState->processingData);
	127	syncState->processingData= NULL;
	128	}
	129
	130
	131	/*
	132	* Read the test case file and make up events. Dispatch those events to the
	133	* matching module.
	134	*
	135	* Args:
	136	* syncState: container for synchronization data.
9c7696b8 BP	137	*
9c7696b8 BP	138	* Returns:
0a87ec9a	139	* AllFactors synchronization factors for each trace pair
48b641c1	140	*/
0a87ec9a	141	static AllFactors* finalizeProcessingText(SyncState* const syncState)
48b641c1	142	{
48b641c1 BP	143	int retval;
48b641c1 BP	144	unsigned int* seq;
0a87ec9a	145	AllFactors* factors;
48b641c1 BP	146	ProcessingDataText* processingData= (ProcessingDataText*)
	147	syncState->processingData;
	148	FILE* testCase= processingData->testCase;
	149	char* line= NULL;
6ce8ceac	150	size_t bufLen;
48b641c1 BP	151
	152	seq= calloc(syncState->traceNb, sizeof(unsigned int));
	153
	154	skipCommentLines(testCase);
6ce8ceac	155	retval= getline(&line, &bufLen, testCase);
48b641c1 BP	156	while(!feof(testCase))
	157	{
	158	unsigned int sender, receiver;
	159	double sendTime, recvTime;
	160	char tmp;
	161	unsigned int i;
	162
	163	if (retval == -1 && !feof(testCase))
	164	{
	165	g_error(strerror(errno));
	166	}
	167
6ce8ceac	168	if (line[retval - 1] == '\n')
48b641c1	169	{
6ce8ceac	170	line[retval - 1]= '\0';
48b641c1 BP	171	}
	172
	173	retval= sscanf(line, " %u %u %lf %lf %c", &sender, &receiver,
	174	&sendTime, &recvTime, &tmp);
	175	if (retval == EOF)
	176	{
	177	g_error(strerror(errno));
	178	}
	179	else if (retval != 4)
	180	{
	181	g_error("Error parsing test file while looking for data point, line was '%s'", line);
	182	}
	183
	184	if (sender + 1 > syncState->traceNb)
	185	{
	186	g_error("Error parsing test file, sender is out of range, line was '%s'", line);
	187	}
	188
	189	if (receiver + 1 > syncState->traceNb)
	190	{
	191	g_error("Error parsing test file, receiver is out of range, line was '%s'", line);
	192	}
	193
	194	if (sendTime < 0)
	195	{
	196	g_error("Error parsing test file, send time is negative, line was '%s'", line);
	197	}
	198
	199	if (recvTime < 0)
	200	{
	201	g_error("Error parsing test file, receive time is negative, line was '%s'", line);
	202	}
	203
	204	// Generate ouput and input events
	205	{
	206	unsigned int addressOffset;
	207	struct {
	208	unsigned int traceNum;
	209	double time;
	210	enum Direction direction;
	211	} loopValues[]= {
	212	{sender, sendTime, OUT},
	213	{receiver, recvTime, IN},
	214	};
	215
	216	/* addressOffset is added to a traceNum to convert it to an address so
	217	* that the address is not plainly the same as the traceNb. */
	218	if (syncState->traceNb > 1)
	219	{
	220	addressOffset= pow(10, floor(log(syncState->traceNb - 1) /
	221	log(10)) + 1);
	222	}
	223	else
	224	{
	225	addressOffset= 0;
	226	}
	227
	228	for (i= 0; i < sizeof(loopValues) / sizeof(*loopValues); i++)
	229	{
	230	Event* event;
	231
	232	event= malloc(sizeof(Event));
	233	event->traceNum= loopValues[i].traceNum;
	234	event->wallTime.seconds= floor(loopValues[i].time);
235	event->wallTime.nanosec= floor((loopValues[i].time -
236	floor(loopValues[i].time)) * NANOSECONDS_PER_SECOND);
237	event->cpuTime= round(loopValues[i].time * CPU_FREQ);
238	event->type= TCP;
239	event->destroy= &destroyTCPEvent;
240	event->event.tcpEvent= malloc(sizeof(TCPEvent));
241	event->event.tcpEvent->direction= loopValues[i].direction;
242	event->event.tcpEvent->segmentKey= malloc(sizeof(SegmentKey));
243	event->event.tcpEvent->segmentKey->ihl= 5;
244	event->event.tcpEvent->segmentKey->tot_len= 40;
245	event->event.tcpEvent->segmentKey->connectionKey.saddr= sender +
246	addressOffset;
247	event->event.tcpEvent->segmentKey->connectionKey.daddr= receiver +
248	addressOffset;
249	event->event.tcpEvent->segmentKey->connectionKey.source= 57645;
250	event->event.tcpEvent->segmentKey->connectionKey.dest= 80;
251	event->event.tcpEvent->segmentKey->seq= seq[sender];
252	event->event.tcpEvent->segmentKey->ack_seq= 0;
253	event->event.tcpEvent->segmentKey->doff= 5;
254	event->event.tcpEvent->segmentKey->ack= 0;
255	event->event.tcpEvent->segmentKey->rst= 0;
256	event->event.tcpEvent->segmentKey->syn= 1;
257	event->event.tcpEvent->segmentKey->fin= 0;
258
259	syncState->matchingModule->matchEvent(syncState, event);
260	}
261	}
262
263	seq[sender]++;
264
265	skipCommentLines(testCase);
6ce8ceac	266	retval= getline(&line, &bufLen, testCase);
48b641c1 BP	267	}
	268
	269	free(seq);
	270
	271	if (line)
	272	{
	273	free(line);
	274	}
	275
	276	factors= syncState->matchingModule->finalizeMatching(syncState);
	277	if (syncState->stats)
	278	{
	279	processingData->factors= factors;
	280	}
9c7696b8 BP	281
9c7696b8 BP	282	return factors;
48b641c1 BP	283	}
	284
	285
48b641c1 BP	286	/*
	287	* Read trace number from the test case stream. The trace number should be the
	288	* first non-comment line and should be an unsigned int by itself on a line.
	289	*
	290	* Args:
	291	* testCase: test case stream
	292	*
	293	* Returns:
	294	* The trace number
	295	*/
	296	static unsigned int readTraceNb(FILE* testCase)
	297	{
	298	unsigned int result;
	299	int retval;
	300	char* line= NULL;
	301	size_t len;
	302	char tmp;
	303
	304	skipCommentLines(testCase);
	305	retval= getline(&line, &len, testCase);
	306	if (retval == -1)
	307	{
	308	if (feof(testCase))
	309	{
	310	g_error("Unexpected end of file while looking for number of traces");
	311	}
	312	else
	313	{
	314	g_error(strerror(errno));
	315	}
	316	}
	317	if (line[retval - 1] == '\n')
	318	{
	319	line[retval - 1]= '\0';
	320	}
	321
	322	retval= sscanf(line, " %u %c", &result, &tmp);
	323	if (retval == EOF \|\| retval != 1)
	324	{
	325	g_error("Error parsing test file while looking for number of traces, line was '%s'", line);
	326
	327	// Not really needed but avoids warning from gcc
	328	abort();
	329	}
	330
6ce8ceac BP	331	if (line)
	332	{
	333	free(line);
	334	}
	335
48b641c1 BP	336	return result;
	337	}
	338
	339
	340	/*
	341	* Advance testCase stream over empty space, empty lines and lines that begin
	342	* with '#'
	343	*
	344	* Args:
	345	* testCase: test case stream
	346	*/
	347	static void skipCommentLines(FILE* testCase)
	348	{
	349	int firstChar;
	350	ssize_t retval;
	351	char* line= NULL;
	352	size_t len;
	353
	354	do
	355	{
	356	firstChar= fgetc(testCase);
	357	if (firstChar == (int) '#')
	358	{
	359	retval= getline(&line, &len, testCase);
	360	if (retval == -1)
	361	{
	362	if (feof(testCase))
	363	{
	364	goto outEof;
	365	}
	366	else
	367	{
	368	g_error(strerror(errno));
	369	}
	370	}
	371	}
	372	else if (firstChar == (int) '\n' \|\| firstChar == (int) ' ')
	373	{}
	374	else if (firstChar == EOF)
	375	{
	376	goto outEof;
	377	}
	378	else
	379	{
	380	break;
	381	}
	382	} while (true);
	383	retval= ungetc(firstChar, testCase);
	384	if (retval == EOF)
	385	{
	386	g_error("Error: ungetc()");
	387	}
	388
	389	outEof:
	390	if (line)
	391	{
	392	free(line);
	393	}
	394	}
	395
	396
	397	/*
	398	* Write the processing-specific variables in the gnuplot script.
	399	*
400	* Args:
401	* syncState: container for synchronization data
402	* i: trace number
403	*/
404	static void writeProcessingGraphVariablesText(SyncState* const syncState,
405	const unsigned int i)
406	{
407	fprintf(syncState->graphsStream, "clock_freq_%u= %.3f\n", i, CPU_FREQ);
408	}
409
410
411	/*
412	* Write the processing-specific options in the gnuplot script.
413	*
414	* Args:
415	* syncState: container for synchronization data
416	* i: first trace number
417	* j: second trace number, garanteed to be larger than i
418	*/
419	static void writeProcessingTraceTraceOptionsText(SyncState* const syncState,
420	const unsigned int i, const unsigned int j)
421	{
422	fprintf(syncState->graphsStream,
423	"set key inside right bottom\n"
424	"set xlabel \"Clock %1$u\"\n"
425	"set xtics nomirror\n"
426	"set ylabel \"Clock %2$u\"\n"
427	"set ytics nomirror\n"
428	"set x2label \"Clock %1$d (s)\"\n"
429	"set x2range [GPVAL_X_MIN / clock_freq_%1$u : GPVAL_X_MAX / clock_freq_%1$u]\n"
430	"set x2tics\n"
431	"set y2label \"Clock %2$d (s)\"\n"
432	"set y2range [GPVAL_Y_MIN / clock_freq_%2$u : GPVAL_Y_MAX / clock_freq_%2$u]\n"
433	"set y2tics\n", i, j);
434	}
435
436
437	/*
438	* Write the processing-specific options in the gnuplot script.
439	*
440	* Args:
441	* syncState: container for synchronization data
442	* i: first trace number
443	* j: second trace number, garanteed to be larger than i
444	*/
445	static void writeProcessingTraceTimeOptionsText(SyncState* const syncState,
446	const unsigned int i, const unsigned int j)
447	{
448	fprintf(syncState->graphsStream,
449	"set key inside right bottom\n"
450	"set xlabel \"Clock %1$u\"\n"
451	"set xtics nomirror\n"
452	"set ylabel \"time (s)\"\n"
453	"set ytics nomirror\n"
454	"set x2label \"Clock %1$d (s)\"\n"
455	"set x2range [GPVAL_X_MIN / clock_freq_%1$u : GPVAL_X_MAX / clock_freq_%1$u]\n"
456	"set x2tics\n", i);
457	}