[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
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
 */
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
d4721e1a BP	70	// Functions specific to this module
d4721e1a BP	71	void gfInitModule(gpointer data, gpointer user_data);
	72	void gfDestroyModule(gpointer data, gpointer user_data);
	73	void gfMatchEvent(gpointer data, gpointer user_data);
	74	void gfFinalize(gpointer data, gpointer user_data);
	75	void gfPrintStats(gpointer data, gpointer user_data);
	76	void gfGraphFunctionCall(gpointer data, gpointer user_data);
	77
	78
	79	static MatchingModule matchingModuleDistributor = {
	80	.name= "distributor",
	81	.canMatch[TCP]= true,
	82	.canMatch[UDP]= true,
	83	.initMatching= &initMatchingDistributor,
	84	.destroyMatching= &destroyMatchingDistributor,
	85	.matchEvent= &matchEventDistributor,
	86	.finalizeMatching= &finalizeMatchingDistributor,
	87	.printMatchingStats= &printMatchingStatsDistributor,
467066ee	88	.graphFunctions= {
c6356aa7 BP	89	.writeTraceTraceForePlots=
	90	&writeMatchingTraceTraceForePlotsDistributor,
	91	.writeTraceTraceBackPlots=
	92	&writeMatchingTraceTraceBackPlotsDistributor,
467066ee	93	.writeTraceTraceOptions= &writeMatchingTraceTraceOptionsDistributor,
c6356aa7 BP	94	.writeTraceTimeForePlots= &writeMatchingTraceTimeForePlotsDistributor,
c6356aa7 BP	95	.writeTraceTimeBackPlots= &writeMatchingTraceTimeBackPlotsDistributor,
467066ee BP	96	.writeTraceTimeOptions= &writeMatchingTraceTimeOptionsDistributor,
467066ee BP	97	},
d4721e1a BP	98	};
	99
	100
	101	/*
	102	* Matching module registering function
	103	*/
2f961b65	104	void registerMatchingDistributor()
d4721e1a BP	105	{
	106	g_queue_push_tail(&matchingModules, &matchingModuleDistributor);
	107	}
	108
	109
	110	/*
	111	* Matching init function
	112	*
	113	* This function is called at the beginning of a synchronization run for a set
	114	* of traces.
	115	*
	116	* Build the list and initialize other matching Modules
	117	*
	118	* Args:
	119	* syncState container for synchronization data.
	120	*/
	121	static void initMatchingDistributor(SyncState* const syncState)
	122	{
	123	MatchingDataDistributor* matchingData;
	124
	125	matchingData= malloc(sizeof(MatchingDataDistributor));
	126	syncState->matchingData= matchingData;
	127
	128	matchingData->distributedModules= g_queue_new();
	129	g_queue_foreach(&matchingModules, &gfInitModule, &(struct InitAggregate)
	130	{syncState, matchingData->distributedModules});
	131	}
	132
	133
	134	/*
	135	* Matching destroy function
	136	*
	137	* Destroy other modules and free the matching specific data structures
	138	*
	139	* Args:
	140	* syncState container for synchronization data.
	141	*/
	142	static void destroyMatchingDistributor(SyncState* const syncState)
	143	{
	144	MatchingDataDistributor* matchingData= syncState->matchingData;
	145
	146	g_queue_foreach(matchingData->distributedModules, &gfDestroyModule, NULL);
	147
	148	g_queue_clear(matchingData->distributedModules);
	149	free(syncState->matchingData);
	150	syncState->matchingData= NULL;
	151	}
	152
	153
	154
	155	/*
	156	* Copy event and distribute to matching modules
	157	*
	158	* Args:
	159	* syncState container for synchronization data.
	160	* event new event to match
	161	*/
	162	static void matchEventDistributor(SyncState* const syncState, Event* const event)
	163	{
	164	MatchingDataDistributor* matchingData= syncState->matchingData;
	165
	166	g_queue_foreach(matchingData->distributedModules, &gfMatchEvent, event);
	167	event->destroy(event);
	168	}
169
170
171	/*
172	* Call the distributed finalization functions and return identity factors
173	*
174	* Args:
175	* syncState container for synchronization data.
176	*
177	* Returns:
178	* Factors[traceNb] identity factors for each trace
179	*/
180	static GArray* finalizeMatchingDistributor(SyncState* const syncState)
181	{
182	GArray* factors;
183	unsigned int i;
184	MatchingDataDistributor* matchingData= syncState->matchingData;
185
186	g_queue_foreach(matchingData->distributedModules, &gfFinalize, NULL);
187
188	factors= g_array_sized_new(FALSE, FALSE, sizeof(Factors),
189	syncState->traceNb);
190	g_array_set_size(factors, syncState->traceNb);
191	for (i= 0; i < syncState->traceNb; i++)
192	{
193	Factors* e;
194
195	e= &g_array_index(factors, Factors, i);
196	e->drift= 1.;
197	e->offset= 0.;
198	}
199
200	return factors;
201	}
202
203
204	/*
205	* Call the distributed statistics functions (when they exist). Must be called
206	* after finalizeMatching.
207	*
208	* Args:
209	* syncState container for synchronization data.
210	*/
211	static void printMatchingStatsDistributor(SyncState* const syncState)
212	{
213	MatchingDataDistributor* matchingData= syncState->matchingData;
214
215	g_queue_foreach(matchingData->distributedModules, &gfPrintStats, NULL);
216	}
217
218
219	/*
220	* Call the distributed graph lines functions (when they exist).
221	*
222	* Args:
d4721e1a BP	223	* syncState: container for synchronization data
	224	* i: first trace number
	225	* j: second trace number, garanteed to be larger than i
	226	*/
c6356aa7 BP	227	static void writeMatchingTraceTraceForePlotsDistributor(SyncState* const
	228	syncState, const unsigned int i, const unsigned int j)
	229	{
	230	MatchingDataDistributor* matchingData= syncState->matchingData;
	231
	232	g_queue_foreach(matchingData->distributedModules, &gfGraphFunctionCall,
	233	&(struct GraphAggregate) {offsetof(MatchingModule,
	234	graphFunctions.writeTraceTraceForePlots), i, j});
	235	}
	236
	237
	238	/*
	239	* Call the distributed graph lines functions (when they exist).
	240	*
	241	* Args:
	242	* syncState: container for synchronization data
	243	* i: first trace number
	244	* j: second trace number, garanteed to be larger than i
	245	*/
	246	static void writeMatchingTraceTraceBackPlotsDistributor(SyncState* const
	247	syncState, const unsigned int i, const unsigned int j)
	248	{
	249	MatchingDataDistributor* matchingData= syncState->matchingData;
	250
	251	g_queue_foreach(matchingData->distributedModules, &gfGraphFunctionCall,
	252	&(struct GraphAggregate) {offsetof(MatchingModule,
	253	graphFunctions.writeTraceTraceBackPlots), i, j});
	254	}
	255
	256
	257	/*
	258	* Call the distributed graph lines functions (when they exist).
	259	*
	260	* Args:
	261	* syncState: container for synchronization data
	262	* i: first trace number
	263	* j: second trace number, garanteed to be larger than i
	264	*/
	265	static void writeMatchingTraceTimeForePlotsDistributor(SyncState* const
467066ee BP	266	syncState, const unsigned int i, const unsigned int j)
	267	{
	268	MatchingDataDistributor* matchingData= syncState->matchingData;
	269
	270	g_queue_foreach(matchingData->distributedModules, &gfGraphFunctionCall,
	271	&(struct GraphAggregate) {offsetof(MatchingModule,
c6356aa7	272	graphFunctions.writeTraceTimeForePlots), i, j});
467066ee BP	273	}
	274
	275
	276	/*
	277	* Call the distributed graph lines functions (when they exist).
	278	*
	279	* Args:
	280	* syncState: container for synchronization data
	281	* i: first trace number
	282	* j: second trace number, garanteed to be larger than i
	283	*/
c6356aa7	284	static void writeMatchingTraceTimeBackPlotsDistributor(SyncState* const
467066ee BP	285	syncState, const unsigned int i, const unsigned int j)
	286	{
	287	MatchingDataDistributor* matchingData= syncState->matchingData;
	288
	289	g_queue_foreach(matchingData->distributedModules, &gfGraphFunctionCall,
	290	&(struct GraphAggregate) {offsetof(MatchingModule,
c6356aa7	291	graphFunctions.writeTraceTimeBackPlots), i, j});
467066ee BP	292	}
	293
	294
	295	/*
	296	* Call the distributed graph options functions (when they exist).
	297	*
	298	* Args:
	299	* syncState: container for synchronization data
	300	* i: first trace number
	301	* j: second trace number, garanteed to be larger than i
	302	*/
	303	static void writeMatchingTraceTraceOptionsDistributor(SyncState* const syncState,
8d7d16dd	304	const unsigned int i, const unsigned int j)
d4721e1a BP	305	{
	306	MatchingDataDistributor* matchingData= syncState->matchingData;
	307
	308	g_queue_foreach(matchingData->distributedModules, &gfGraphFunctionCall,
	309	&(struct GraphAggregate) {offsetof(MatchingModule,
467066ee	310	graphFunctions.writeTraceTraceOptions), i, j});
d4721e1a BP	311	}
	312
	313
	314	/*
	315	* Call the distributed graph options functions (when they exist).
	316	*
	317	* Args:
d4721e1a BP	318	* syncState: container for synchronization data
	319	* i: first trace number
	320	* j: second trace number, garanteed to be larger than i
	321	*/
467066ee	322	static void writeMatchingTraceTimeOptionsDistributor(SyncState* const syncState,
8d7d16dd	323	const unsigned int i, const unsigned int j)
d4721e1a BP	324	{
	325	MatchingDataDistributor* matchingData= syncState->matchingData;
	326
	327	g_queue_foreach(matchingData->distributedModules, &gfGraphFunctionCall,
	328	&(struct GraphAggregate) {offsetof(MatchingModule,
467066ee	329	graphFunctions.writeTraceTimeOptions), i, j});
d4721e1a BP	330	}
	331
	332
	333	/*
	334	* A GFunc for g_queue_foreach()
	335	*
	336	* Add and initialize matching module
	337	*
	338	* Args:
	339	* data MatchingModule*, module to add
	340	* user_data InitAggregate*
	341	*/
	342	void gfInitModule(gpointer data, gpointer user_data)
	343	{
	344	SyncState* parallelSS;
	345	struct InitAggregate* aggregate= user_data;
	346	MatchingModule* matchingModule= data;
	347
	348	if (strcmp(matchingModule->name, matchingModuleDistributor.name) == 0)
	349	{
	350	return;
	351	}
	352
	353	parallelSS= malloc(sizeof(SyncState));
	354	memcpy(parallelSS, aggregate->syncState, sizeof(SyncState));
	355	g_queue_push_tail(aggregate->matchingModules, parallelSS);
	356
	357	parallelSS->matchingModule= matchingModule;
	358	parallelSS->matchingModule->initMatching(parallelSS);
	359	}
	360
	361
	362	/*
	363	* A GFunc for g_queue_foreach()
	364	*
	365	* Destroy and remove matching module
	366	*
	367	* Args:
	368	* data SyncState* containing the module to destroy
	369	* user_data NULL
	370	*/
	371	void gfDestroyModule(gpointer data, gpointer user_data)
	372	{
	373	SyncState* parallelSS= data;
	374
	375	parallelSS->matchingModule->destroyMatching(parallelSS);
	376	free(parallelSS);
	377	}
	378
	379
	380	/*
	381	* A GFunc for g_queue_foreach()
	382	*
	383	* Args:
	384	* data SyncState* containing the distributed matching module
	385	* user_data Event* original event
	386	*/
	387	void gfMatchEvent(gpointer data, gpointer user_data)
	388	{
	389	SyncState* parallelSS= data;
	390	const Event* event= user_data;
	391	Event* newEvent;
	392
	393	if (parallelSS->matchingModule->canMatch[event->type])
394	{
395	event->copy(event, &newEvent);
396	parallelSS->matchingModule->matchEvent(parallelSS, newEvent);
397	}
398	}
399
400
401	/*
402	* A GFunc for g_queue_foreach()
403	*
404	* Args:
405	* data SyncState* containing the distributed matching module
406	* user_data NULL
407	*/
408	void gfFinalize(gpointer data, gpointer user_data)
409	{
410	GArray* factors;
411	SyncState* parallelSS= data;
412
413	factors= parallelSS->matchingModule->finalizeMatching(parallelSS);
414	g_array_free(factors, TRUE);
415	}
416
417
418	/*
419	* A GFunc for g_queue_foreach()
420	*
421	* Args:
422	* data SyncState* containing the distributed matching module
423	* user_data NULL
424	*/
425	void gfPrintStats(gpointer data, gpointer user_data)
426	{
427	SyncState* parallelSS= data;
428
429	if (parallelSS->matchingModule->printMatchingStats != NULL)
430	{
431	parallelSS->matchingModule->printMatchingStats(parallelSS);
432	}
433	}
434
435
436	/*
437	* A GFunc for g_queue_foreach()
438	*
439	* Call a certain matching function
440	*
441	* Args:
442	* data SyncState* containing the distributed matching module
443	* user_data size_t,
444	*/
445	void gfGraphFunctionCall(gpointer data, gpointer user_data)
446	{
447	SyncState* parallelSS= data;
448	struct GraphAggregate* aggregate= user_data;
e072e1ab BP	449	typedef void (GraphFunction)(struct _SyncState, const unsigned int,
	450	const unsigned int);
	451	GraphFunction graphFunction= (GraphFunction)((void*)
	452	parallelSS->matchingModule + (size_t) aggregate->offset);
d4721e1a BP	453
	454	if (graphFunction != NULL)
	455	{
8d7d16dd	456	graphFunction(parallelSS, aggregate->i, aggregate->j);
d4721e1a BP	457	}
d4721e1a BP	458	}