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

/* This file is part of the Linux Trace Toolkit viewer
 * Copyright (C) 2009 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 General Public License Version 2 as
 * published by the Free Software Foundation;
 *
 * 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 General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, write to the Free Software
 * Foundation, Inc., 59 Temple Place - Suite 330, Boston,
 * MA 02111-1307, USA.
 */

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

#include <stdlib.h>
#include <stddef.h>
#include <string.h>

#include "event_analysis.h"
#include "sync_chain.h"

#include "event_matching_distributor.h"


struct InitAggregate
{
	SyncState* syncState;
	GQueue* matchingModules;
};


struct GraphAggregate
{
	/* Offset whithin Matching module of the field* containing the function
	 * pointer */
	size_t offset;
	unsigned int i, j;
};


// Functions common to all matching modules
static void initMatchingDistributor(SyncState* const syncState);
static void destroyMatchingDistributor(SyncState* const syncState);

static void matchEventDistributor(SyncState* const syncState, Event* const
	event);
static GArray* finalizeMatchingDistributor(SyncState* const syncState);
static void printMatchingStatsDistributor(SyncState* const syncState);
static void writeMatchingTraceTraceForePlotsDistributor(SyncState* const
	syncState, const unsigned int i, const unsigned int j);
static void writeMatchingTraceTraceBackPlotsDistributor(SyncState* const
	syncState, const unsigned int i, const unsigned int j);
static void writeMatchingTraceTraceOptionsDistributor(SyncState* const
	syncState, const unsigned int i, const unsigned int j);
static void writeMatchingTraceTimeForePlotsDistributor(SyncState* const
	syncState, const unsigned int i, const unsigned int j);
static void writeMatchingTraceTimeBackPlotsDistributor(SyncState* const
	syncState, const unsigned int i, const unsigned int j);
static void writeMatchingTraceTimeOptionsDistributor(SyncState* const
	syncState, const unsigned int i, const unsigned int j);

// Functions specific to this module
static void registerMatchingDistributor() __attribute__((constructor (101)));

void gfInitModule(gpointer data, gpointer user_data);
void gfDestroyModule(gpointer data, gpointer user_data);
void gfMatchEvent(gpointer data, gpointer user_data);
void gfFinalize(gpointer data, gpointer user_data);
void gfPrintStats(gpointer data, gpointer user_data);
void gfGraphFunctionCall(gpointer data, gpointer user_data);


static MatchingModule matchingModuleDistributor = {
	.name= "distributor",
	.canMatch[TCP]= true,
	.canMatch[UDP]= true,
	.initMatching= &initMatchingDistributor,
	.destroyMatching= &destroyMatchingDistributor,
	.matchEvent= &matchEventDistributor,
	.finalizeMatching= &finalizeMatchingDistributor,
	.printMatchingStats= &printMatchingStatsDistributor,
	.graphFunctions= {
		.writeTraceTraceForePlots=
			&writeMatchingTraceTraceForePlotsDistributor,
		.writeTraceTraceBackPlots=
			&writeMatchingTraceTraceBackPlotsDistributor,
		.writeTraceTraceOptions= &writeMatchingTraceTraceOptionsDistributor,
		.writeTraceTimeForePlots= &writeMatchingTraceTimeForePlotsDistributor,
		.writeTraceTimeBackPlots= &writeMatchingTraceTimeBackPlotsDistributor,
		.writeTraceTimeOptions= &writeMatchingTraceTimeOptionsDistributor,
	},
};


/*
 * Matching module registering function
 */
static void registerMatchingDistributor()
{
	g_queue_push_tail(&matchingModules, &matchingModuleDistributor);
}


/*
 * Matching init function
 *
 * This function is called at the beginning of a synchronization run for a set
 * of traces.
 *
 * Build the list and initialize other matching Modules
 *
 * Args:
 *   syncState     container for synchronization data.
 */
static void initMatchingDistributor(SyncState* const syncState)
{
	MatchingDataDistributor* matchingData;

	matchingData= malloc(sizeof(MatchingDataDistributor));
	syncState->matchingData= matchingData;

	matchingData->distributedModules= g_queue_new();
	g_queue_foreach(&matchingModules, &gfInitModule, &(struct InitAggregate)
		{syncState, matchingData->distributedModules});
}


/*
 * Matching destroy function
 *
 * Destroy other modules and free the matching specific data structures
 *
 * Args:
 *   syncState     container for synchronization data.
 */
static void destroyMatchingDistributor(SyncState* const syncState)
{
	MatchingDataDistributor* matchingData= syncState->matchingData;

	g_queue_foreach(matchingData->distributedModules, &gfDestroyModule, NULL);

	g_queue_clear(matchingData->distributedModules);
	free(syncState->matchingData);
	syncState->matchingData= NULL;
}


/*
 * Copy event and distribute to matching modules
 *
 * Args:
 *   syncState     container for synchronization data.
 *   event         new event to match
 */
static void matchEventDistributor(SyncState* const syncState, Event* const event)
{
	MatchingDataDistributor* matchingData= syncState->matchingData;

	g_queue_foreach(matchingData->distributedModules, &gfMatchEvent, event);
	event->destroy(event);
}


/*
 * Call the distributed finalization functions and return identity factors
 *
 * Args:
 *   syncState     container for synchronization data.
 *
 * Returns:
 *   Factors[traceNb] identity factors for each trace
 */
static GArray* finalizeMatchingDistributor(SyncState* const syncState)
{
	GArray* factors;
	unsigned int i;
	MatchingDataDistributor* matchingData= syncState->matchingData;

	g_queue_foreach(matchingData->distributedModules, &gfFinalize, NULL);

	factors= g_array_sized_new(FALSE, FALSE, sizeof(Factors),
		syncState->traceNb);
	g_array_set_size(factors, syncState->traceNb);
	for (i= 0; i < syncState->traceNb; i++)
	{
		Factors* e;

		e= &g_array_index(factors, Factors, i);
		e->drift= 1.;
		e->offset= 0.;
	}

	return factors;
}


/*
 * Call the distributed statistics functions (when they exist). Must be called
 * after finalizeMatching.
 *
 * Args:
 *   syncState     container for synchronization data.
 */
static void printMatchingStatsDistributor(SyncState* const syncState)
{
	MatchingDataDistributor* matchingData= syncState->matchingData;

	g_queue_foreach(matchingData->distributedModules, &gfPrintStats, NULL);
}


/*
 * Call the distributed graph lines functions (when they exist).
 *
 * Args:
 *   syncState:    container for synchronization data
 *   i:            first trace number
 *   j:            second trace number, garanteed to be larger than i
 */
static void writeMatchingTraceTraceForePlotsDistributor(SyncState* const
	syncState, const unsigned int i, const unsigned int j)
{
	MatchingDataDistributor* matchingData= syncState->matchingData;

	g_queue_foreach(matchingData->distributedModules, &gfGraphFunctionCall,
		&(struct GraphAggregate) {offsetof(MatchingModule,
			graphFunctions.writeTraceTraceForePlots), i, j});
}


/*
 * Call the distributed graph lines functions (when they exist).
 *
 * Args:
 *   syncState:    container for synchronization data
 *   i:            first trace number
 *   j:            second trace number, garanteed to be larger than i
 */
static void writeMatchingTraceTraceBackPlotsDistributor(SyncState* const
	syncState, const unsigned int i, const unsigned int j)
{
	MatchingDataDistributor* matchingData= syncState->matchingData;

	g_queue_foreach(matchingData->distributedModules, &gfGraphFunctionCall,
		&(struct GraphAggregate) {offsetof(MatchingModule,
			graphFunctions.writeTraceTraceBackPlots), i, j});
}


/*
 * Call the distributed graph lines functions (when they exist).
 *
 * Args:
 *   syncState:    container for synchronization data
 *   i:            first trace number
 *   j:            second trace number, garanteed to be larger than i
 */
static void writeMatchingTraceTimeForePlotsDistributor(SyncState* const
	syncState, const unsigned int i, const unsigned int j)
{
	MatchingDataDistributor* matchingData= syncState->matchingData;

	g_queue_foreach(matchingData->distributedModules, &gfGraphFunctionCall,
		&(struct GraphAggregate) {offsetof(MatchingModule,
			graphFunctions.writeTraceTimeForePlots), i, j});
}


/*
 * Call the distributed graph lines functions (when they exist).
 *
 * Args:
 *   syncState:    container for synchronization data
 *   i:            first trace number
 *   j:            second trace number, garanteed to be larger than i
 */
static void writeMatchingTraceTimeBackPlotsDistributor(SyncState* const
	syncState, const unsigned int i, const unsigned int j)
{
	MatchingDataDistributor* matchingData= syncState->matchingData;

	g_queue_foreach(matchingData->distributedModules, &gfGraphFunctionCall,
		&(struct GraphAggregate) {offsetof(MatchingModule,
			graphFunctions.writeTraceTimeBackPlots), i, j});
}


/*
 * Call the distributed graph options functions (when they exist).
 *
 * Args:
 *   syncState:    container for synchronization data
 *   i:            first trace number
 *   j:            second trace number, garanteed to be larger than i
 */
static void writeMatchingTraceTraceOptionsDistributor(SyncState* const syncState,
	const unsigned int i, const unsigned int j)
{
	MatchingDataDistributor* matchingData= syncState->matchingData;

	g_queue_foreach(matchingData->distributedModules, &gfGraphFunctionCall,
		&(struct GraphAggregate) {offsetof(MatchingModule,
			graphFunctions.writeTraceTraceOptions), i, j});
}


/*
 * Call the distributed graph options functions (when they exist).
 *
 * Args:
 *   syncState:    container for synchronization data
 *   i:            first trace number
 *   j:            second trace number, garanteed to be larger than i
 */
static void writeMatchingTraceTimeOptionsDistributor(SyncState* const syncState,
	const unsigned int i, const unsigned int j)
{
	MatchingDataDistributor* matchingData= syncState->matchingData;

	g_queue_foreach(matchingData->distributedModules, &gfGraphFunctionCall,
		&(struct GraphAggregate) {offsetof(MatchingModule,
			graphFunctions.writeTraceTimeOptions), i, j});
}


/*
 * A GFunc for g_queue_foreach()
 *
 * Add and initialize matching module
 *
 * Args:
 *   data          MatchingModule*, module to add
 *   user_data     InitAggregate*
 */
void gfInitModule(gpointer data, gpointer user_data)
{
	SyncState* parallelSS;
	struct InitAggregate* aggregate= user_data;
	MatchingModule* matchingModule= data;

	if (strcmp(matchingModule->name, matchingModuleDistributor.name) == 0)
	{
		return;
	}

	parallelSS= malloc(sizeof(SyncState));
	memcpy(parallelSS, aggregate->syncState, sizeof(SyncState));
	g_queue_push_tail(aggregate->matchingModules, parallelSS);

	parallelSS->matchingModule= matchingModule;
	parallelSS->matchingModule->initMatching(parallelSS);
}


/*
 * A GFunc for g_queue_foreach()
 *
 * Destroy and remove matching module
 *
 * Args:
 *   data          SyncState* containing the module to destroy
 *   user_data     NULL
 */
void gfDestroyModule(gpointer data, gpointer user_data)
{
	SyncState* parallelSS= data;

	parallelSS->matchingModule->destroyMatching(parallelSS);
	free(parallelSS);
}


/*
 * A GFunc for g_queue_foreach()
 *
 * Args:
 *   data          SyncState* containing the distributed matching module
 *   user_data     Event* original event
 */
void gfMatchEvent(gpointer data, gpointer user_data)
{
	SyncState* parallelSS= data;
	const Event* event= user_data;
	Event* newEvent;

	if (parallelSS->matchingModule->canMatch[event->type])
	{
		event->copy(event, &newEvent);
		parallelSS->matchingModule->matchEvent(parallelSS, newEvent);
	}
}


/*
 * A GFunc for g_queue_foreach()
 *
 * Args:
 *   data          SyncState* containing the distributed matching module
 *   user_data     NULL
 */
void gfFinalize(gpointer data, gpointer user_data)
{
	GArray* factors;
	SyncState* parallelSS= data;

	factors= parallelSS->matchingModule->finalizeMatching(parallelSS);
	g_array_free(factors, TRUE);
}


/*
 * A GFunc for g_queue_foreach()
 *
 * Args:
 *   data          SyncState* containing the distributed matching module
 *   user_data     NULL
 */
void gfPrintStats(gpointer data, gpointer user_data)
{
	SyncState* parallelSS= data;

	if (parallelSS->matchingModule->printMatchingStats != NULL)
	{
		parallelSS->matchingModule->printMatchingStats(parallelSS);
	}
}


/*
 * A GFunc for g_queue_foreach()
 *
 * Call a certain matching function
 *
 * Args:
 *   data          SyncState* containing the distributed matching module
 *   user_data     size_t,
 */
void gfGraphFunctionCall(gpointer data, gpointer user_data)
{
	SyncState* parallelSS= data;
	struct GraphAggregate* aggregate= user_data;
	typedef void (*GraphFunction)(struct _SyncState*, const unsigned int,
		const unsigned int);
	GraphFunction graphFunction= *(GraphFunction*)((void*)
		parallelSS->matchingModule + (size_t) aggregate->offset);

	if (graphFunction != NULL)
	{
		graphFunction(parallelSS, aggregate->i, aggregate->j);
	}
}
Commit	Line	Data
d4721e1a BP	1	/* This file is part of the Linux Trace Toolkit viewer
	2	* Copyright (C) 2009 Benjamin Poirier <benjamin.poirier@polymtl.ca>
	3	*
	4	* This program is free software; you can redistribute it and/or modify
	5	* it under the terms of the GNU General Public License Version 2 as
	6	* published by the Free Software Foundation;
	7	*
	8	* This program is distributed in the hope that it will be useful,
	9	* but WITHOUT ANY WARRANTY; without even the implied warranty of
	10	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
	11	* GNU General Public License for more details.
	12	*
	13	* You should have received a copy of the GNU General Public License
	14	* along with this program; if not, write to the Free Software
	15	* Foundation, Inc., 59 Temple Place - Suite 330, Boston,
	16	* MA 02111-1307, USA.
	17	*/
	18
	19	#ifdef HAVE_CONFIG_H
	20	#include <config.h>
	21	#endif
	22
	23	#include <stdlib.h>
	24	#include <stddef.h>
	25	#include <string.h>
	26
	27	#include "event_analysis.h"
	28	#include "sync_chain.h"
	29
	30	#include "event_matching_distributor.h"
	31
	32
	33	struct InitAggregate
	34	{
	35	SyncState* syncState;
	36	GQueue* matchingModules;
	37	};
	38
	39
	40	struct GraphAggregate
	41	{
	42	/* Offset whithin Matching module of the field* containing the function
	43	* pointer */
	44	size_t offset;
d4721e1a BP	45	unsigned int i, j;
	46	};
	47
	48
	49	// Functions common to all matching modules
	50	static void initMatchingDistributor(SyncState* const syncState);
	51	static void destroyMatchingDistributor(SyncState* const syncState);
	52
	53	static void matchEventDistributor(SyncState* const syncState, Event* const
	54	event);
	55	static GArray* finalizeMatchingDistributor(SyncState* const syncState);
	56	static void printMatchingStatsDistributor(SyncState* const syncState);
c6356aa7 BP	57	static void writeMatchingTraceTraceForePlotsDistributor(SyncState* const
	58	syncState, const unsigned int i, const unsigned int j);
	59	static void writeMatchingTraceTraceBackPlotsDistributor(SyncState* const
467066ee BP	60	syncState, const unsigned int i, const unsigned int j);
	61	static void writeMatchingTraceTraceOptionsDistributor(SyncState* const
	62	syncState, const unsigned int i, const unsigned int j);
c6356aa7 BP	63	static void writeMatchingTraceTimeForePlotsDistributor(SyncState* const
	64	syncState, const unsigned int i, const unsigned int j);
	65	static void writeMatchingTraceTimeBackPlotsDistributor(SyncState* const
467066ee BP	66	syncState, const unsigned int i, const unsigned int j);
	67	static void writeMatchingTraceTimeOptionsDistributor(SyncState* const
	68	syncState, const unsigned int i, const unsigned int j);
d4721e1a BP	69
	70	// Functions specific to this module
	71	static void registerMatchingDistributor() __attribute__((constructor (101)));
	72
	73	void gfInitModule(gpointer data, gpointer user_data);
	74	void gfDestroyModule(gpointer data, gpointer user_data);
	75	void gfMatchEvent(gpointer data, gpointer user_data);
	76	void gfFinalize(gpointer data, gpointer user_data);
	77	void gfPrintStats(gpointer data, gpointer user_data);
	78	void gfGraphFunctionCall(gpointer data, gpointer user_data);
	79
	80
	81	static MatchingModule matchingModuleDistributor = {
	82	.name= "distributor",
	83	.canMatch[TCP]= true,
	84	.canMatch[UDP]= true,
	85	.initMatching= &initMatchingDistributor,
	86	.destroyMatching= &destroyMatchingDistributor,
	87	.matchEvent= &matchEventDistributor,
	88	.finalizeMatching= &finalizeMatchingDistributor,
	89	.printMatchingStats= &printMatchingStatsDistributor,
467066ee	90	.graphFunctions= {
c6356aa7 BP	91	.writeTraceTraceForePlots=
	92	&writeMatchingTraceTraceForePlotsDistributor,
	93	.writeTraceTraceBackPlots=
	94	&writeMatchingTraceTraceBackPlotsDistributor,
467066ee	95	.writeTraceTraceOptions= &writeMatchingTraceTraceOptionsDistributor,
c6356aa7 BP	96	.writeTraceTimeForePlots= &writeMatchingTraceTimeForePlotsDistributor,
c6356aa7 BP	97	.writeTraceTimeBackPlots= &writeMatchingTraceTimeBackPlotsDistributor,
467066ee BP	98	.writeTraceTimeOptions= &writeMatchingTraceTimeOptionsDistributor,
467066ee BP	99	},
d4721e1a BP	100	};
	101
	102
	103	/*
	104	* Matching module registering function
	105	*/
	106	static void registerMatchingDistributor()
	107	{
	108	g_queue_push_tail(&matchingModules, &matchingModuleDistributor);
	109	}
	110
	111
	112	/*
	113	* Matching init function
	114	*
	115	* This function is called at the beginning of a synchronization run for a set
	116	* of traces.
	117	*
	118	* Build the list and initialize other matching Modules
	119	*
	120	* Args:
	121	* syncState container for synchronization data.
	122	*/
	123	static void initMatchingDistributor(SyncState* const syncState)
	124	{
	125	MatchingDataDistributor* matchingData;
	126
	127	matchingData= malloc(sizeof(MatchingDataDistributor));
	128	syncState->matchingData= matchingData;
	129
	130	matchingData->distributedModules= g_queue_new();
	131	g_queue_foreach(&matchingModules, &gfInitModule, &(struct InitAggregate)
	132	{syncState, matchingData->distributedModules});
	133	}
	134
	135
	136	/*
	137	* Matching destroy function
	138	*
	139	* Destroy other modules and free the matching specific data structures
	140	*
	141	* Args:
	142	* syncState container for synchronization data.
	143	*/
	144	static void destroyMatchingDistributor(SyncState* const syncState)
	145	{
	146	MatchingDataDistributor* matchingData= syncState->matchingData;
	147
	148	g_queue_foreach(matchingData->distributedModules, &gfDestroyModule, NULL);
	149
	150	g_queue_clear(matchingData->distributedModules);
	151	free(syncState->matchingData);
	152	syncState->matchingData= NULL;
	153	}
	154
	155
	156
	157	/*
	158	* Copy event and distribute to matching modules
	159	*
	160	* Args:
	161	* syncState container for synchronization data.
	162	* event new event to match
	163	*/
164	static void matchEventDistributor(SyncState* const syncState, Event* const event)
165	{
166	MatchingDataDistributor* matchingData= syncState->matchingData;
167
168	g_queue_foreach(matchingData->distributedModules, &gfMatchEvent, event);
169	event->destroy(event);
170	}
171
172
173	/*
174	* Call the distributed finalization functions and return identity factors
175	*
176	* Args:
177	* syncState container for synchronization data.
178	*
179	* Returns:
180	* Factors[traceNb] identity factors for each trace
181	*/
182	static GArray* finalizeMatchingDistributor(SyncState* const syncState)
183	{
184	GArray* factors;
185	unsigned int i;
186	MatchingDataDistributor* matchingData= syncState->matchingData;
187
188	g_queue_foreach(matchingData->distributedModules, &gfFinalize, NULL);
189
190	factors= g_array_sized_new(FALSE, FALSE, sizeof(Factors),
191	syncState->traceNb);
192	g_array_set_size(factors, syncState->traceNb);
193	for (i= 0; i < syncState->traceNb; i++)
194	{
195	Factors* e;
196
197	e= &g_array_index(factors, Factors, i);
198	e->drift= 1.;
199	e->offset= 0.;
200	}
201
202	return factors;
203	}
204
205
206	/*
207	* Call the distributed statistics functions (when they exist). Must be called
208	* after finalizeMatching.
209	*
210	* Args:
211	* syncState container for synchronization data.
212	*/
213	static void printMatchingStatsDistributor(SyncState* const syncState)
214	{
215	MatchingDataDistributor* matchingData= syncState->matchingData;
216
217	g_queue_foreach(matchingData->distributedModules, &gfPrintStats, NULL);
218	}
219
220
221	/*
222	* Call the distributed graph lines functions (when they exist).
223	*
224	* Args:
d4721e1a BP	225	* syncState: container for synchronization data
	226	* i: first trace number
	227	* j: second trace number, garanteed to be larger than i
	228	*/
c6356aa7 BP	229	static void writeMatchingTraceTraceForePlotsDistributor(SyncState* const
	230	syncState, const unsigned int i, const unsigned int j)
	231	{
	232	MatchingDataDistributor* matchingData= syncState->matchingData;
	233
	234	g_queue_foreach(matchingData->distributedModules, &gfGraphFunctionCall,
	235	&(struct GraphAggregate) {offsetof(MatchingModule,
	236	graphFunctions.writeTraceTraceForePlots), i, j});
	237	}
	238
	239
	240	/*
	241	* Call the distributed graph lines functions (when they exist).
	242	*
	243	* Args:
	244	* syncState: container for synchronization data
	245	* i: first trace number
	246	* j: second trace number, garanteed to be larger than i
	247	*/
	248	static void writeMatchingTraceTraceBackPlotsDistributor(SyncState* const
	249	syncState, const unsigned int i, const unsigned int j)
	250	{
	251	MatchingDataDistributor* matchingData= syncState->matchingData;
	252
	253	g_queue_foreach(matchingData->distributedModules, &gfGraphFunctionCall,
	254	&(struct GraphAggregate) {offsetof(MatchingModule,
	255	graphFunctions.writeTraceTraceBackPlots), i, j});
	256	}
	257
	258
	259	/*
	260	* Call the distributed graph lines functions (when they exist).
	261	*
	262	* Args:
	263	* syncState: container for synchronization data
	264	* i: first trace number
	265	* j: second trace number, garanteed to be larger than i
	266	*/
	267	static void writeMatchingTraceTimeForePlotsDistributor(SyncState* const
467066ee BP	268	syncState, const unsigned int i, const unsigned int j)
	269	{
	270	MatchingDataDistributor* matchingData= syncState->matchingData;
	271
	272	g_queue_foreach(matchingData->distributedModules, &gfGraphFunctionCall,
	273	&(struct GraphAggregate) {offsetof(MatchingModule,
c6356aa7	274	graphFunctions.writeTraceTimeForePlots), i, j});
467066ee BP	275	}
	276
	277
	278	/*
	279	* Call the distributed graph lines functions (when they exist).
	280	*
	281	* Args:
	282	* syncState: container for synchronization data
	283	* i: first trace number
	284	* j: second trace number, garanteed to be larger than i
	285	*/
c6356aa7	286	static void writeMatchingTraceTimeBackPlotsDistributor(SyncState* const
467066ee BP	287	syncState, const unsigned int i, const unsigned int j)
	288	{
	289	MatchingDataDistributor* matchingData= syncState->matchingData;
	290
	291	g_queue_foreach(matchingData->distributedModules, &gfGraphFunctionCall,
	292	&(struct GraphAggregate) {offsetof(MatchingModule,
c6356aa7	293	graphFunctions.writeTraceTimeBackPlots), i, j});
467066ee BP	294	}
	295
	296
	297	/*
	298	* Call the distributed graph options functions (when they exist).
	299	*
	300	* Args:
	301	* syncState: container for synchronization data
	302	* i: first trace number
	303	* j: second trace number, garanteed to be larger than i
	304	*/
	305	static void writeMatchingTraceTraceOptionsDistributor(SyncState* const syncState,
8d7d16dd	306	const unsigned int i, const unsigned int j)
d4721e1a BP	307	{
	308	MatchingDataDistributor* matchingData= syncState->matchingData;
	309
	310	g_queue_foreach(matchingData->distributedModules, &gfGraphFunctionCall,
	311	&(struct GraphAggregate) {offsetof(MatchingModule,
467066ee	312	graphFunctions.writeTraceTraceOptions), i, j});
d4721e1a BP	313	}
	314
	315
	316	/*
	317	* Call the distributed graph options functions (when they exist).
	318	*
	319	* Args:
d4721e1a BP	320	* syncState: container for synchronization data
	321	* i: first trace number
	322	* j: second trace number, garanteed to be larger than i
	323	*/
467066ee	324	static void writeMatchingTraceTimeOptionsDistributor(SyncState* const syncState,
8d7d16dd	325	const unsigned int i, const unsigned int j)
d4721e1a BP	326	{
	327	MatchingDataDistributor* matchingData= syncState->matchingData;
	328
	329	g_queue_foreach(matchingData->distributedModules, &gfGraphFunctionCall,
	330	&(struct GraphAggregate) {offsetof(MatchingModule,
467066ee	331	graphFunctions.writeTraceTimeOptions), i, j});
d4721e1a BP	332	}
	333
	334
	335	/*
	336	* A GFunc for g_queue_foreach()
	337	*
	338	* Add and initialize matching module
	339	*
	340	* Args:
	341	* data MatchingModule*, module to add
	342	* user_data InitAggregate*
	343	*/
	344	void gfInitModule(gpointer data, gpointer user_data)
	345	{
	346	SyncState* parallelSS;
	347	struct InitAggregate* aggregate= user_data;
	348	MatchingModule* matchingModule= data;
	349
	350	if (strcmp(matchingModule->name, matchingModuleDistributor.name) == 0)
	351	{
	352	return;
	353	}
	354
	355	parallelSS= malloc(sizeof(SyncState));
	356	memcpy(parallelSS, aggregate->syncState, sizeof(SyncState));
	357	g_queue_push_tail(aggregate->matchingModules, parallelSS);
	358
	359	parallelSS->matchingModule= matchingModule;
	360	parallelSS->matchingModule->initMatching(parallelSS);
	361	}
	362
	363
	364	/*
	365	* A GFunc for g_queue_foreach()
	366	*
	367	* Destroy and remove matching module
	368	*
	369	* Args:
	370	* data SyncState* containing the module to destroy
	371	* user_data NULL
	372	*/
	373	void gfDestroyModule(gpointer data, gpointer user_data)
	374	{
	375	SyncState* parallelSS= data;
	376
	377	parallelSS->matchingModule->destroyMatching(parallelSS);
	378	free(parallelSS);
	379	}
	380
	381
	382	/*
	383	* A GFunc for g_queue_foreach()
	384	*
	385	* Args:
	386	* data SyncState* containing the distributed matching module
	387	* user_data Event* original event
	388	*/
	389	void gfMatchEvent(gpointer data, gpointer user_data)
	390	{
	391	SyncState* parallelSS= data;
	392	const Event* event= user_data;
	393	Event* newEvent;
	394
	395	if (parallelSS->matchingModule->canMatch[event->type])
396	{
397	event->copy(event, &newEvent);
398	parallelSS->matchingModule->matchEvent(parallelSS, newEvent);
399	}
400	}
401
402
403	/*
404	* A GFunc for g_queue_foreach()
405	*
406	* Args:
407	* data SyncState* containing the distributed matching module
408	* user_data NULL
409	*/
410	void gfFinalize(gpointer data, gpointer user_data)
411	{
412	GArray* factors;
413	SyncState* parallelSS= data;
414
415	factors= parallelSS->matchingModule->finalizeMatching(parallelSS);
416	g_array_free(factors, TRUE);
417	}
418
419
420	/*
421	* A GFunc for g_queue_foreach()
422	*
423	* Args:
424	* data SyncState* containing the distributed matching module
425	* user_data NULL
426	*/
427	void gfPrintStats(gpointer data, gpointer user_data)
428	{
429	SyncState* parallelSS= data;
430
431	if (parallelSS->matchingModule->printMatchingStats != NULL)
432	{
433	parallelSS->matchingModule->printMatchingStats(parallelSS);
434	}
435	}
436
437
438	/*
439	* A GFunc for g_queue_foreach()
440	*
441	* Call a certain matching function
442	*
443	* Args:
444	* data SyncState* containing the distributed matching module
445	* user_data size_t,
446	*/
447	void gfGraphFunctionCall(gpointer data, gpointer user_data)
448	{
449	SyncState* parallelSS= data;
450	struct GraphAggregate* aggregate= user_data;
e072e1ab BP	451	typedef void (GraphFunction)(struct _SyncState, const unsigned int,
	452	const unsigned int);
	453	GraphFunction graphFunction= (GraphFunction)((void*)
	454	parallelSS->matchingModule + (size_t) aggregate->offset);
d4721e1a BP	455
	456	if (graphFunction != NULL)
	457	{
8d7d16dd	458	graphFunction(parallelSS, aggregate->i, aggregate->j);
d4721e1a BP	459	}
d4721e1a BP	460	}