1 /* This file is part of the Linux Trace Toolkit viewer
2 * Copyright (C) 2009, 2010 Benjamin Poirier <benjamin.poirier@polymtl.ca>
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.
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.
14 * You should have received a copy of the GNU Lesser General Public License
15 * along with this program. If not, see <http://www.gnu.org/licenses/>.
18 #define _ISOC99_SOURCE
29 #include <sys/resource.h>
31 #include <sys/types.h>
35 #include <lttv/module.h>
36 #include <lttv/option.h>
39 #include "event_processing_lttng_standard.h"
40 #include "event_processing_lttng_null.h"
41 #include "event_matching_tcp.h"
42 #include "event_matching_broadcast.h"
43 #include "event_matching_distributor.h"
44 #include "event_analysis_chull.h"
45 #include "event_analysis_linreg.h"
46 #include "event_analysis_eval.h"
47 #include "sync_chain.h"
48 #include "sync_chain_lttv.h"
52 static void destroy();
54 static void gfAddModuleOption(gpointer data
, gpointer user_data
);
55 static void gfRemoveModuleOption(gpointer data
, gpointer user_data
);
57 static ModuleOption optionSync
= {
60 .optionHelp
= "synchronize the time between the traces",
62 static ModuleOption optionSyncStats
= {
63 .longName
= "sync-stats",
65 .optionHelp
= "print statistics about the time synchronization",
67 static ModuleOption optionSyncNull
= {
68 .longName
= "sync-null",
70 .optionHelp
= "read the events but do not perform any processing",
72 static GString
* analysisModulesNames
;
73 static ModuleOption optionSyncAnalysis
= {
74 .longName
= "sync-analysis",
75 .hasArg
= REQUIRED_ARG
,
76 .optionHelp
= "specify the algorithm to use for event analysis",
78 static ModuleOption optionSyncGraphs
= {
79 .longName
= "sync-graphs",
81 .optionHelp
= "output gnuplot graph showing synchronization points",
83 static char graphsDir
[20];
84 static ModuleOption optionSyncGraphsDir
= {
85 .longName
= "sync-graphs-dir",
86 .hasArg
= REQUIRED_ARG
,
87 .optionHelp
= "specify the directory where to store the graphs",
92 * Module init function
94 * This function is declared to be the module initialization function.
100 g_debug("Sync init");
103 * Initialize event modules
104 * Call the "constructor" or initialization function of each event module
105 * so it can register itself. This must be done before elements in
106 * processingModules, matchingModules, analysisModules or moduleOptions
109 registerProcessingLTTVStandard();
110 registerProcessingLTTVNull();
112 registerMatchingTCP();
113 registerMatchingBroadcast();
114 registerMatchingDistributor();
116 registerAnalysisCHull();
117 registerAnalysisLinReg();
118 registerAnalysisEval();
120 g_assert(g_queue_get_length(&analysisModules
) > 0);
121 optionSyncAnalysis
.arg
= ((AnalysisModule
*)
122 g_queue_peek_head(&analysisModules
))->name
;
123 analysisModulesNames
= g_string_new("");
124 g_queue_foreach(&analysisModules
, &gfAppendAnalysisName
,
125 analysisModulesNames
);
126 // remove the last ", "
127 g_string_truncate(analysisModulesNames
, analysisModulesNames
->len
- 2);
128 optionSyncAnalysis
.argHelp
= analysisModulesNames
->str
;
130 retval
= snprintf(graphsDir
, sizeof(graphsDir
), "graphs-%d", getpid());
131 if (retval
> sizeof(graphsDir
) - 1)
133 graphsDir
[sizeof(graphsDir
) - 1]= '\0';
135 optionSyncGraphsDir
.arg
= graphsDir
;
136 optionSyncGraphsDir
.argHelp
= graphsDir
;
138 g_queue_push_head(&moduleOptions
, &optionSyncGraphsDir
);
139 g_queue_push_head(&moduleOptions
, &optionSyncGraphs
);
140 g_queue_push_head(&moduleOptions
, &optionSyncAnalysis
);
141 g_queue_push_head(&moduleOptions
, &optionSyncNull
);
142 g_queue_push_head(&moduleOptions
, &optionSyncStats
);
143 g_queue_push_head(&moduleOptions
, &optionSync
);
145 g_queue_foreach(&moduleOptions
, &gfAddModuleOption
, NULL
);
150 * Module unload function
152 static void destroy()
154 g_debug("Sync destroy");
156 g_queue_foreach(&moduleOptions
, &gfRemoveModuleOption
, NULL
);
157 g_string_free(analysisModulesNames
, TRUE
);
159 g_queue_clear(&processingModules
);
160 g_queue_clear(&matchingModules
);
161 g_queue_clear(&analysisModules
);
162 g_queue_clear(&moduleOptions
);
167 * Calculate a traceset's drift and offset values based on network events
169 * The individual correction factors are written out to each trace.
172 * traceSetContext: traceset
175 * false if synchronization was not performed, true otherwise
177 bool syncTraceset(LttvTracesetContext
* const traceSetContext
)
179 SyncState
* syncState
;
180 struct timeval startTime
, endTime
;
181 struct rusage startUsage
, endUsage
;
184 AllFactors
* allFactors
;
186 double minOffset
, minDrift
;
187 unsigned int refFreqTrace
;
190 if (!optionSync
.present
)
192 g_debug("Not synchronizing traceset because option is disabled");
196 if (optionSyncStats
.present
)
198 gettimeofday(&startTime
, 0);
199 getrusage(RUSAGE_SELF
, &startUsage
);
202 // Initialize data structures
203 syncState
= malloc(sizeof(SyncState
));
205 if (optionSyncStats
.present
)
207 syncState
->stats
= true;
211 syncState
->stats
= false;
214 if (!optionSyncNull
.present
&& optionSyncGraphs
.present
)
216 // Create the graph directory right away in case the module initialization
217 // functions have something to write in it.
218 syncState
->graphsDir
= optionSyncGraphsDir
.arg
;
219 syncState
->graphsStream
= createGraphsDir(syncState
->graphsDir
);
223 syncState
->graphsStream
= NULL
;
224 syncState
->graphsDir
= NULL
;
227 // Identify and initialize modules
228 syncState
->processingData
= NULL
;
229 if (optionSyncNull
.present
)
231 result
= g_queue_find_custom(&processingModules
, "LTTV-null",
232 &gcfCompareProcessing
);
236 result
= g_queue_find_custom(&processingModules
, "LTTV-standard",
237 &gcfCompareProcessing
);
239 g_assert(result
!= NULL
);
240 syncState
->processingModule
= (ProcessingModule
*) result
->data
;
242 syncState
->matchingData
= NULL
;
243 result
= g_queue_find_custom(&matchingModules
, "TCP", &gcfCompareMatching
);
244 g_assert(result
!= NULL
);
245 syncState
->matchingModule
= (MatchingModule
*) result
->data
;
247 syncState
->analysisData
= NULL
;
248 result
= g_queue_find_custom(&analysisModules
, optionSyncAnalysis
.arg
,
249 &gcfCompareAnalysis
);
252 syncState
->analysisModule
= (AnalysisModule
*) result
->data
;
256 g_error("Analysis module '%s' not found", optionSyncAnalysis
.arg
);
259 syncState
->processingModule
->initProcessing(syncState
, traceSetContext
);
260 if (!optionSyncNull
.present
)
262 syncState
->matchingModule
->initMatching(syncState
);
263 syncState
->analysisModule
->initAnalysis(syncState
);
267 lttv_process_traceset_seek_time(traceSetContext
, ltt_time_zero
);
268 lttv_process_traceset_middle(traceSetContext
, ltt_time_infinite
,
270 lttv_process_traceset_seek_time(traceSetContext
, ltt_time_zero
);
272 // Obtain, reduce, adjust and set correction factors
273 allFactors
= syncState
->processingModule
->finalizeProcessing(syncState
);
274 factors
= reduceFactors(allFactors
);
275 freeAllFactors(allFactors
);
277 /* The offsets are adjusted so the lowest one is 0. This is done because
278 * of a Lttv specific limitation: events cannot have negative times. By
279 * having non-negative offsets, events cannot be moved backwards to
283 for (i
= 0; i
< syncState
->traceNb
; i
++)
285 minOffset
= MIN(g_array_index(factors
, Factors
, i
).offset
, minOffset
);
288 for (i
= 0; i
< syncState
->traceNb
; i
++)
290 g_array_index(factors
, Factors
, i
).offset
-= minOffset
;
293 /* Because the timestamps are corrected at the TSC level (not at the
294 * LttTime level) all trace frequencies must be made equal. We use the
295 * frequency of the system with the lowest drift
299 for (i
= 0; i
< syncState
->traceNb
; i
++)
301 if (g_array_index(factors
, Factors
, i
).drift
< minDrift
)
303 minDrift
= g_array_index(factors
, Factors
, i
).drift
;
307 g_assert(syncState
->traceNb
== 0 || minDrift
!= INFINITY
);
309 // Write the factors to the LttTrace structures
310 for (i
= 0; i
< syncState
->traceNb
; i
++)
313 Factors
* traceFactors
;
315 t
= traceSetContext
->traces
[i
]->t
;
316 traceFactors
= &g_array_index(factors
, Factors
, i
);
318 t
->drift
= traceFactors
->drift
;
319 t
->offset
= traceFactors
->offset
;
320 t
->start_freq
= traceSetContext
->traces
[refFreqTrace
]->t
->start_freq
;
321 t
->freq_scale
= traceSetContext
->traces
[refFreqTrace
]->t
->freq_scale
;
322 t
->start_time_from_tsc
=
323 ltt_time_from_uint64(tsc_to_uint64(t
->freq_scale
, t
->start_freq
,
324 t
->drift
* t
->start_tsc
+ t
->offset
));
327 g_array_free(factors
, TRUE
);
329 lttv_traceset_context_compute_time_span(traceSetContext
,
330 &traceSetContext
->time_span
);
332 g_debug("traceset start %ld.%09ld end %ld.%09ld",
333 traceSetContext
->time_span
.start_time
.tv_sec
,
334 traceSetContext
->time_span
.start_time
.tv_nsec
,
335 traceSetContext
->time_span
.end_time
.tv_sec
,
336 traceSetContext
->time_span
.end_time
.tv_nsec
);
339 if (!optionSyncNull
.present
&& optionSyncGraphs
.present
)
341 writeGraphsScript(syncState
);
343 if (fclose(syncState
->graphsStream
) != 0)
345 g_error(strerror(errno
));
349 if (!optionSyncNull
.present
&& optionSyncStats
.present
)
351 printStats(syncState
);
353 printf("Resulting synchronization factors:\n");
354 for (i
= 0; i
< syncState
->traceNb
; i
++)
358 t
= traceSetContext
->traces
[i
]->t
;
360 printf("\ttrace %u drift= %g offset= %g (%f) start time= %ld.%09ld\n",
361 i
, t
->drift
, t
->offset
, (double) tsc_to_uint64(t
->freq_scale
,
362 t
->start_freq
, t
->offset
) / NANOSECONDS_PER_SECOND
,
363 t
->start_time_from_tsc
.tv_sec
,
364 t
->start_time_from_tsc
.tv_nsec
);
368 syncState
->processingModule
->destroyProcessing(syncState
);
369 if (syncState
->matchingModule
!= NULL
)
371 syncState
->matchingModule
->destroyMatching(syncState
);
373 if (syncState
->analysisModule
!= NULL
)
375 syncState
->analysisModule
->destroyAnalysis(syncState
);
380 if (optionSyncStats
.present
)
382 gettimeofday(&endTime
, 0);
383 retval
= getrusage(RUSAGE_SELF
, &endUsage
);
385 timeDiff(&endTime
, &startTime
);
386 timeDiff(&endUsage
.ru_utime
, &startUsage
.ru_utime
);
387 timeDiff(&endUsage
.ru_stime
, &startUsage
.ru_stime
);
389 printf("Synchronization time:\n");
390 printf("\treal time: %ld.%06ld\n", endTime
.tv_sec
, endTime
.tv_usec
);
391 printf("\tuser time: %ld.%06ld\n", endUsage
.ru_utime
.tv_sec
,
392 endUsage
.ru_utime
.tv_usec
);
393 printf("\tsystem time: %ld.%06ld\n", endUsage
.ru_stime
.tv_sec
,
394 endUsage
.ru_stime
.tv_usec
);
402 * A GFunc for g_queue_foreach()
405 * data: ModuleOption*
408 static void gfAddModuleOption(gpointer data
, gpointer user_data
)
410 ModuleOption
* option
= data
;
411 LttvOptionType conversion
[]= {
412 [NO_ARG
]= LTTV_OPT_NONE
,
413 [OPTIONAL_ARG
]= LTTV_OPT_NONE
,
414 [REQUIRED_ARG
]= LTTV_OPT_STRING
,
416 size_t fieldOffset
[]= {
417 [NO_ARG
]= offsetof(ModuleOption
, present
),
418 [REQUIRED_ARG
]= offsetof(ModuleOption
, arg
),
420 static const char* argHelpNone
= "none";
422 g_assert_cmpuint(sizeof(conversion
) / sizeof(*conversion
), ==,
424 if (option
->hasArg
== OPTIONAL_ARG
)
426 g_warning("Parameters with optional arguments not supported by the "
427 "lttv option scheme, parameter '%s' will not be available",
432 lttv_option_add(option
->longName
, '\0', option
->optionHelp
,
433 option
->argHelp
? option
->argHelp
: argHelpNone
,
434 conversion
[option
->hasArg
], (void*) option
+ fieldOffset
[option
->hasArg
],
441 * A GFunc for g_queue_foreach()
444 * data: ModuleOption*
447 static void gfRemoveModuleOption(gpointer data
, gpointer user_data
)
449 lttv_option_remove(((ModuleOption
*) data
)->longName
);
453 LTTV_MODULE("sync", "Synchronize traces", \
454 "Synchronizes a traceset based on the correspondance of network events", \
455 init
, destroy
, "option")