Commit | Line | Data |
---|---|---|
f10c27a8 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 <errno.h> | |
24 | #include <stdlib.h> | |
25 | #include <string.h> | |
26 | #include <unistd.h> | |
27 | ||
28 | #include "event_analysis.h" | |
2bd4b3e4 | 29 | #include "sync_chain.h" |
f10c27a8 BP |
30 | |
31 | #include "event_matching_broadcast.h" | |
32 | ||
33 | ||
34 | #ifndef g_info | |
35 | #define g_info(format...) g_log (G_LOG_DOMAIN, G_LOG_LEVEL_INFO, format) | |
36 | #endif | |
37 | ||
38 | ||
39 | // Functions common to all matching modules | |
40 | static void initMatchingBroadcast(SyncState* const syncState); | |
41 | static void destroyMatchingBroadcast(SyncState* const syncState); | |
42 | ||
43 | static void matchEventBroadcast(SyncState* const syncState, Event* const event); | |
44 | static GArray* finalizeMatchingBroadcast(SyncState* const syncState); | |
45 | static void printMatchingStatsBroadcast(SyncState* const syncState); | |
46 | ||
47 | // Functions specific to this module | |
48 | static void registerMatchingBroadcast() __attribute__((constructor (101))); | |
49 | ||
50 | static void partialDestroyMatchingBroadcast(SyncState* const syncState); | |
51 | ||
52 | static MatchingModule matchingModuleBroadcast = { | |
53 | .name= "broadcast", | |
54 | .canMatch[TCP]= false, | |
55 | .canMatch[UDP]= true, | |
56 | .initMatching= &initMatchingBroadcast, | |
57 | .destroyMatching= &destroyMatchingBroadcast, | |
58 | .matchEvent= &matchEventBroadcast, | |
59 | .finalizeMatching= &finalizeMatchingBroadcast, | |
60 | .printMatchingStats= &printMatchingStatsBroadcast, | |
61 | .writeMatchingGraphsPlots= NULL, | |
62 | .writeMatchingGraphsOptions= NULL, | |
63 | }; | |
64 | ||
65 | ||
66 | /* | |
67 | * Matching module registering function | |
68 | */ | |
69 | static void registerMatchingBroadcast() | |
70 | { | |
71 | g_queue_push_tail(&matchingModules, &matchingModuleBroadcast); | |
72 | } | |
73 | ||
74 | ||
75 | /* | |
76 | * Matching init function | |
77 | * | |
78 | * This function is called at the beginning of a synchronization run for a set | |
79 | * of traces. | |
80 | * | |
81 | * Allocate the matching specific data structures | |
82 | * | |
83 | * Args: | |
84 | * syncState container for synchronization data. | |
85 | * This function allocates these matchingData members: | |
86 | * pendingBroadcasts | |
87 | * stats | |
88 | */ | |
89 | static void initMatchingBroadcast(SyncState* const syncState) | |
90 | { | |
91 | MatchingDataBroadcast* matchingData; | |
92 | ||
93 | matchingData= malloc(sizeof(MatchingDataBroadcast)); | |
94 | syncState->matchingData= matchingData; | |
95 | ||
96 | matchingData->pendingBroadcasts= g_hash_table_new_full(&ghfDatagramKeyHash, | |
97 | &gefDatagramKeyEqual, &gdnDestroyDatagramKey, &gdnDestroyBroadcast); | |
98 | ||
99 | if (syncState->stats) | |
100 | { | |
101 | matchingData->stats= calloc(1, sizeof(MatchingStatsBroadcast)); | |
102 | } | |
103 | else | |
104 | { | |
105 | matchingData->stats= NULL; | |
106 | } | |
107 | } | |
108 | ||
109 | ||
110 | /* | |
111 | * Matching destroy function | |
112 | * | |
113 | * Free the matching specific data structures | |
114 | * | |
115 | * Args: | |
116 | * syncState container for synchronization data. | |
117 | * This function deallocates these matchingData members: | |
118 | * stats | |
119 | */ | |
120 | static void destroyMatchingBroadcast(SyncState* const syncState) | |
121 | { | |
122 | MatchingDataBroadcast* matchingData; | |
123 | ||
124 | matchingData= (MatchingDataBroadcast*) syncState->matchingData; | |
125 | ||
126 | if (matchingData == NULL) | |
127 | { | |
128 | return; | |
129 | } | |
130 | ||
131 | partialDestroyMatchingBroadcast(syncState); | |
132 | ||
133 | if (syncState->stats) | |
134 | { | |
135 | free(matchingData->stats); | |
136 | } | |
137 | ||
138 | free(syncState->matchingData); | |
139 | syncState->matchingData= NULL; | |
140 | } | |
141 | ||
142 | ||
143 | /* | |
144 | * Free some of the matching specific data structures | |
145 | * | |
146 | * This function can be called right after the events have been processed to | |
147 | * free some data structures that are not needed for finalization. | |
148 | * | |
149 | * Args: | |
150 | * syncState container for synchronization data. | |
151 | * This function deallocates these matchingData members: | |
152 | * pendingBroadcasts | |
153 | */ | |
154 | static void partialDestroyMatchingBroadcast(SyncState* const syncState) | |
155 | { | |
156 | MatchingDataBroadcast* matchingData; | |
157 | ||
158 | matchingData= (MatchingDataBroadcast*) syncState->matchingData; | |
159 | ||
160 | if (matchingData == NULL || matchingData->pendingBroadcasts == NULL) | |
161 | { | |
162 | return; | |
163 | } | |
164 | ||
165 | g_hash_table_destroy(matchingData->pendingBroadcasts); | |
166 | matchingData->pendingBroadcasts= NULL; | |
167 | } | |
168 | ||
169 | ||
170 | /* | |
171 | * Try to match one broadcast with previously received broadcasts (based on | |
172 | * the addresses and the fist bytes of data they contain). Deliver them to the | |
173 | * analysis module once a traceNb events have been accumulated for a | |
174 | * broadcast. | |
175 | * | |
176 | * Args: | |
177 | * syncState container for synchronization data. | |
178 | * event new event to match | |
179 | */ | |
180 | static void matchEventBroadcast(SyncState* const syncState, Event* const event) | |
181 | { | |
182 | MatchingDataBroadcast* matchingData; | |
183 | ||
184 | g_assert(event->type == UDP); | |
185 | ||
186 | matchingData= (MatchingDataBroadcast*) syncState->matchingData; | |
187 | ||
188 | if (!event->event.udpEvent->unicast) | |
189 | { | |
190 | if (event->event.udpEvent->direction == IN) | |
191 | { | |
192 | Broadcast* broadcast; | |
193 | DatagramKey* datagramKey; | |
194 | gboolean result; | |
195 | ||
196 | if (matchingData->stats) | |
197 | { | |
198 | matchingData->stats->totReceive++; | |
199 | } | |
200 | ||
d4721e1a BP |
201 | /* if event in pendingBroadcasts: |
202 | * add it to its broadcast | |
203 | * if this broadcast has traceNb events: | |
204 | * remove it from pending and deliver it to analysis | |
205 | * destroy the broadcast (and its elements) | |
206 | * else: | |
207 | * create a broadcast and add it to pending | |
208 | */ | |
f10c27a8 BP |
209 | |
210 | result= | |
211 | g_hash_table_lookup_extended(matchingData->pendingBroadcasts, | |
212 | event->event.udpEvent->datagramKey, (gpointer) | |
213 | &datagramKey, (gpointer) &broadcast); | |
214 | if (result) | |
215 | { | |
216 | g_queue_push_tail(broadcast->events, event); | |
217 | if (broadcast->events->length == syncState->traceNb) | |
218 | { | |
2bd4b3e4 BP |
219 | if (matchingData->stats) |
220 | { | |
221 | matchingData->stats->totComplete++; | |
222 | } | |
223 | ||
f10c27a8 BP |
224 | g_hash_table_steal(matchingData->pendingBroadcasts, datagramKey); |
225 | free(datagramKey); | |
226 | syncState->analysisModule->analyzeBroadcast(syncState, broadcast); | |
227 | destroyBroadcast(broadcast); | |
228 | } | |
229 | } | |
230 | else | |
231 | { | |
232 | broadcast= malloc(sizeof(Broadcast)); | |
233 | broadcast->events= g_queue_new(); | |
234 | g_queue_push_tail(broadcast->events, event); | |
2bd4b3e4 BP |
235 | |
236 | datagramKey= malloc(sizeof(DatagramKey)); | |
237 | *datagramKey= *event->event.udpEvent->datagramKey; | |
238 | ||
239 | g_hash_table_insert(matchingData->pendingBroadcasts, | |
240 | datagramKey, broadcast); | |
f10c27a8 BP |
241 | } |
242 | } | |
243 | else | |
244 | { | |
245 | if (matchingData->stats) | |
246 | { | |
247 | matchingData->stats->totTransmit++; | |
248 | } | |
249 | ||
250 | event->destroy(event); | |
251 | } | |
252 | } | |
253 | else | |
254 | { | |
255 | event->destroy(event); | |
256 | } | |
257 | ||
258 | } | |
259 | ||
260 | ||
261 | /* | |
262 | * Call the partial matching destroyer and Obtain the factors from downstream | |
263 | * | |
264 | * Args: | |
265 | * syncState container for synchronization data. | |
266 | * | |
267 | * Returns: | |
268 | * Factors[traceNb] synchronization factors for each trace | |
269 | */ | |
270 | static GArray* finalizeMatchingBroadcast(SyncState* const syncState) | |
271 | { | |
272 | MatchingDataBroadcast* matchingData; | |
273 | ||
274 | matchingData= (MatchingDataBroadcast*) syncState->matchingData; | |
275 | ||
276 | if (matchingData->stats) | |
277 | { | |
278 | matchingData->stats->totIncomplete= | |
279 | g_hash_table_size(matchingData->pendingBroadcasts); | |
280 | } | |
281 | ||
282 | partialDestroyMatchingBroadcast(syncState); | |
283 | ||
284 | return syncState->analysisModule->finalizeAnalysis(syncState); | |
285 | } | |
286 | ||
287 | ||
288 | /* | |
289 | * Print statistics related to matching and downstream modules. Must be | |
290 | * called after finalizeMatching. | |
291 | * | |
292 | * Args: | |
293 | * syncState container for synchronization data. | |
294 | */ | |
295 | static void printMatchingStatsBroadcast(SyncState* const syncState) | |
296 | { | |
297 | MatchingDataBroadcast* matchingData; | |
298 | ||
299 | if (!syncState->stats) | |
300 | { | |
301 | return; | |
302 | } | |
f10c27a8 BP |
303 | matchingData= (MatchingDataBroadcast*) syncState->matchingData; |
304 | ||
305 | printf("Broadcast matching stats:\n"); | |
306 | printf("\ttotal broadcasts datagrams emitted: %u\n", | |
307 | matchingData->stats->totTransmit); | |
308 | printf("\ttotal broadcasts datagrams received: %u\n", | |
309 | matchingData->stats->totReceive); | |
76be6fc2 | 310 | printf("\ttotal broadcast groups for which all receptions were identified: %u\n", |
f10c27a8 | 311 | matchingData->stats->totComplete); |
76be6fc2 | 312 | printf("\ttotal broadcast groups missing some receptions: %u\n", |
f10c27a8 BP |
313 | matchingData->stats->totIncomplete); |
314 | if (matchingData->stats->totIncomplete > 0) | |
315 | { | |
316 | printf("\taverage number of broadcast datagrams received in incomplete groups: %f\n", | |
317 | (double) (matchingData->stats->totReceive - | |
318 | matchingData->stats->totComplete * syncState->traceNb) / | |
319 | matchingData->stats->totIncomplete); | |
320 | } | |
321 | ||
322 | if (syncState->analysisModule->printAnalysisStats != NULL) | |
323 | { | |
324 | syncState->analysisModule->printAnalysisStats(syncState); | |
325 | } | |
326 | } |