2 #include <lttv/processTrace.h>
4 #include <ltt/facility.h>
8 void lttv_context_init(LttvTracesetContext
*self
, LttvTraceset
*ts
)
10 LTTV_TRACESET_CONTEXT_GET_CLASS(self
)->init(self
, ts
);
14 void lttv_context_fini(LttvTracesetContext
*self
)
16 LTTV_TRACESET_CONTEXT_GET_CLASS(self
)->fini(self
);
21 lttv_context_new_traceset_context(LttvTracesetContext
*self
)
23 return LTTV_TRACESET_CONTEXT_GET_CLASS(self
)->new_traceset_context(self
);
30 lttv_context_new_trace_context(LttvTracesetContext
*self
)
32 return LTTV_TRACESET_CONTEXT_GET_CLASS(self
)->new_trace_context(self
);
36 LttvTracefileContext
*
37 lttv_context_new_tracefile_context(LttvTracesetContext
*self
)
39 return LTTV_TRACESET_CONTEXT_GET_CLASS(self
)->new_tracefile_context(self
);
42 /****************************************************************************
43 * lttv_traceset_context_compute_time_span
45 * Keep the Time_Span is sync with on the fly addition and removal of traces
46 * in a trace set. It must be called each time a trace is added/removed from
47 * the traceset. It could be more efficient to call it only once a bunch
48 * of traces are loaded, but the calculation is not long, so it's not
51 * Author : Xang Xiu Yang
52 * Imported from gtkTraceSet.c by Mathieu Desnoyers
53 ***************************************************************************/
54 static void lttv_traceset_context_compute_time_span(
55 LttvTracesetContext
*self
,
56 TimeInterval
*Time_Span
)
58 LttvTraceset
* traceset
= self
->ts
;
59 int numTraces
= lttv_traceset_number(traceset
);
65 for(i
=0; i
<numTraces
;i
++){
69 ltt_trace_time_span_get(trace
, &s
, &e
);
72 Time_Span
->startTime
= s
;
73 Time_Span
->endTime
= e
;
75 if(s
.tv_sec
< Time_Span
->startTime
.tv_sec
||
76 (s
.tv_sec
== Time_Span
->startTime
.tv_sec
77 && s
.tv_nsec
< Time_Span
->startTime
.tv_nsec
))
78 Time_Span
->startTime
= s
;
79 if(e
.tv_sec
> Time_Span
->endTime
.tv_sec
||
80 (e
.tv_sec
== Time_Span
->endTime
.tv_sec
&&
81 e
.tv_nsec
> Time_Span
->endTime
.tv_nsec
))
82 Time_Span
->endTime
= e
;
89 init(LttvTracesetContext
*self
, LttvTraceset
*ts
)
91 guint i
, j
, nb_trace
, nb_control
, nb_per_cpu
, nb_tracefile
;
95 LttvTracefileContext
*tfc
;
97 LttTime null_time
= {0, 0};
99 nb_trace
= lttv_traceset_number(ts
);
101 self
->traces
= g_new(LttvTraceContext
*, nb_trace
);
102 self
->before
= lttv_hooks_new();
103 self
->after
= lttv_hooks_new();
104 self
->a
= g_object_new(LTTV_ATTRIBUTE_TYPE
, NULL
);
105 self
->ts_a
= lttv_traceset_attribute(ts
);
106 for(i
= 0 ; i
< nb_trace
; i
++) {
107 tc
= LTTV_TRACESET_CONTEXT_GET_CLASS(self
)->new_trace_context(self
);
108 self
->traces
[i
] = tc
;
110 tc
->ts_context
= self
;
112 tc
->vt
= lttv_traceset_get(ts
, i
);
113 tc
->t
= lttv_trace(tc
->vt
);
114 tc
->check
= lttv_hooks_new();
115 tc
->before
= lttv_hooks_new();
116 tc
->after
= lttv_hooks_new();
117 tc
->a
= g_object_new(LTTV_ATTRIBUTE_TYPE
, NULL
);
118 tc
->t_a
= lttv_trace_attribute(tc
->vt
);
119 nb_control
= ltt_trace_control_tracefile_number(tc
->t
);
120 nb_per_cpu
= ltt_trace_per_cpu_tracefile_number(tc
->t
);
121 nb_tracefile
= nb_control
+ nb_per_cpu
;
122 tc
->control_tracefiles
= g_new(LttvTracefileContext
*, nb_control
);
123 tc
->per_cpu_tracefiles
= g_new(LttvTracefileContext
*, nb_per_cpu
);
125 for(j
= 0 ; j
< nb_tracefile
; j
++) {
126 tfc
= LTTV_TRACESET_CONTEXT_GET_CLASS(self
)->new_tracefile_context(self
);
128 tc
->control_tracefiles
[j
] = tfc
;
131 tfc
->tf
= ltt_trace_control_tracefile_get(tc
->t
, j
);
134 tc
->per_cpu_tracefiles
[j
- nb_control
] = tfc
;
135 tfc
->control
= FALSE
;
136 tfc
->index
= j
- nb_control
;
137 tfc
->tf
= ltt_trace_per_cpu_tracefile_get(tc
->t
, j
- nb_control
);
140 tfc
->check
= lttv_hooks_new();
141 tfc
->before
= lttv_hooks_new();
142 tfc
->after
= lttv_hooks_new();
143 tfc
->check_event
= lttv_hooks_new();
144 tfc
->before_event
= lttv_hooks_new();
145 tfc
->before_event_by_id
= lttv_hooks_by_id_new();
146 tfc
->after_event
= lttv_hooks_new();
147 tfc
->after_event_by_id
= lttv_hooks_by_id_new();
148 tfc
->a
= g_object_new(LTTV_ATTRIBUTE_TYPE
, NULL
);
151 lttv_process_traceset_seek_time(self
, null_time
);
152 /*CHECK why dynamically allocate the time span... and the casing is wroNg*/
153 self
->Time_Span
= g_new(TimeInterval
,1);
154 lttv_traceset_context_compute_time_span(self
, self
->Time_Span
);
158 void fini(LttvTracesetContext
*self
)
160 guint i
, j
, nb_trace
, nb_control
, nb_per_cpu
, nb_tracefile
;
162 LttvTraceContext
*tc
;
164 LttvTracefileContext
*tfc
;
166 LttvTraceset
*ts
= self
->ts
;
168 g_free(self
->Time_Span
);
170 lttv_hooks_destroy(self
->before
);
171 lttv_hooks_destroy(self
->after
);
173 g_object_unref(self
->a
);
175 nb_trace
= lttv_traceset_number(ts
);
177 for(i
= 0 ; i
< nb_trace
; i
++) {
178 tc
= self
->traces
[i
];
180 lttv_hooks_destroy(tc
->check
);
181 lttv_hooks_destroy(tc
->before
);
182 lttv_hooks_destroy(tc
->after
);
183 g_object_unref(tc
->a
);
185 nb_control
= ltt_trace_control_tracefile_number(tc
->t
);
186 nb_per_cpu
= ltt_trace_per_cpu_tracefile_number(tc
->t
);
187 nb_tracefile
= nb_control
+ nb_per_cpu
;
189 for(j
= 0 ; j
< nb_tracefile
; j
++) {
190 if(j
< nb_control
) tfc
= tc
->control_tracefiles
[j
];
191 else tfc
= tc
->per_cpu_tracefiles
[j
- nb_control
];
193 lttv_hooks_destroy(tfc
->check
);
194 lttv_hooks_destroy(tfc
->before
);
195 lttv_hooks_destroy(tfc
->after
);
196 lttv_hooks_destroy(tfc
->check_event
);
197 lttv_hooks_destroy(tfc
->before_event
);
198 lttv_hooks_by_id_destroy(tfc
->before_event_by_id
);
199 lttv_hooks_destroy(tfc
->after_event
);
200 lttv_hooks_by_id_destroy(tfc
->after_event_by_id
);
201 g_object_unref(tfc
->a
);
204 g_free(tc
->control_tracefiles
);
205 g_free(tc
->per_cpu_tracefiles
);
208 g_free(self
->traces
);
212 void lttv_traceset_context_add_hooks(LttvTracesetContext
*self
,
213 LttvHooks
*before_traceset
,
214 LttvHooks
*after_traceset
,
215 LttvHooks
*check_trace
,
216 LttvHooks
*before_trace
,
217 LttvHooks
*after_trace
,
218 LttvHooks
*check_tracefile
,
219 LttvHooks
*before_tracefile
,
220 LttvHooks
*after_tracefile
,
221 LttvHooks
*check_event
,
222 LttvHooks
*before_event
,
223 LttvHooks
*after_event
)
225 LttvTraceset
*ts
= self
->ts
;
227 guint i
, j
, nb_trace
, nb_control
, nb_per_cpu
, nb_tracefile
;
229 LttvTraceContext
*tc
;
231 LttvTracefileContext
*tfc
;
235 lttv_hooks_add_list(self
->before
, before_traceset
);
236 lttv_hooks_add_list(self
->after
, after_traceset
);
237 nb_trace
= lttv_traceset_number(ts
);
239 for(i
= 0 ; i
< nb_trace
; i
++) {
240 tc
= self
->traces
[i
];
241 lttv_hooks_add_list(tc
->check
, check_trace
);
242 lttv_hooks_add_list(tc
->before
, before_trace
);
243 lttv_hooks_add_list(tc
->after
, after_trace
);
244 nb_control
= ltt_trace_control_tracefile_number(tc
->t
);
245 nb_per_cpu
= ltt_trace_per_cpu_tracefile_number(tc
->t
);
246 nb_tracefile
= nb_control
+ nb_per_cpu
;
248 for(j
= 0 ; j
< nb_tracefile
; j
++) {
250 tfc
= tc
->control_tracefiles
[j
];
253 tfc
= tc
->per_cpu_tracefiles
[j
-nb_control
];
255 lttv_hooks_add_list(tfc
->check
, check_tracefile
);
256 lttv_hooks_add_list(tfc
->before
, before_tracefile
);
257 lttv_hooks_add_list(tfc
->after
, after_tracefile
);
258 lttv_hooks_add_list(tfc
->check_event
, check_event
);
259 lttv_hooks_add_list(tfc
->before_event
, before_event
);
260 lttv_hooks_add_list(tfc
->after_event
, after_event
);
266 void lttv_traceset_context_remove_hooks(LttvTracesetContext
*self
,
267 LttvHooks
*before_traceset
,
268 LttvHooks
*after_traceset
,
269 LttvHooks
*check_trace
,
270 LttvHooks
*before_trace
,
271 LttvHooks
*after_trace
,
272 LttvHooks
*check_tracefile
,
273 LttvHooks
*before_tracefile
,
274 LttvHooks
*after_tracefile
,
275 LttvHooks
*check_event
,
276 LttvHooks
*before_event
,
277 LttvHooks
*after_event
)
279 LttvTraceset
*ts
= self
->ts
;
281 guint i
, j
, nb_trace
, nb_control
, nb_per_cpu
, nb_tracefile
;
283 LttvTraceContext
*tc
;
285 LttvTracefileContext
*tfc
;
289 lttv_hooks_remove_list(self
->before
, before_traceset
);
290 lttv_hooks_remove_list(self
->after
, after_traceset
);
291 nb_trace
= lttv_traceset_number(ts
);
293 for(i
= 0 ; i
< nb_trace
; i
++) {
294 tc
= self
->traces
[i
];
295 lttv_hooks_remove_list(tc
->check
, check_trace
);
296 lttv_hooks_remove_list(tc
->before
, before_trace
);
297 lttv_hooks_remove_list(tc
->after
, after_trace
);
298 nb_control
= ltt_trace_control_tracefile_number(tc
->t
);
299 nb_per_cpu
= ltt_trace_per_cpu_tracefile_number(tc
->t
);
300 nb_tracefile
= nb_control
+ nb_per_cpu
;
302 for(j
= 0 ; j
< nb_tracefile
; j
++) {
304 tfc
= tc
->control_tracefiles
[j
];
307 tfc
= tc
->per_cpu_tracefiles
[j
-nb_control
];
309 lttv_hooks_remove_list(tfc
->check
, check_tracefile
);
310 lttv_hooks_remove_list(tfc
->before
, before_tracefile
);
311 lttv_hooks_remove_list(tfc
->after
, after_tracefile
);
312 lttv_hooks_remove_list(tfc
->check_event
, check_event
);
313 lttv_hooks_remove_list(tfc
->before_event
, before_event
);
314 lttv_hooks_remove_list(tfc
->after_event
, after_event
);
319 void lttv_trace_context_add_hooks(LttvTraceContext
*tc
,
320 LttvHooks
*check_trace
,
321 LttvHooks
*before_trace
,
322 LttvHooks
*after_trace
)
324 lttv_hooks_add_list(tc
->check
, check_trace
);
325 lttv_hooks_add_list(tc
->before
, before_trace
);
326 lttv_hooks_add_list(tc
->after
, after_trace
);
329 void lttv_trace_context_remove_hooks(LttvTraceContext
*tc
,
330 LttvHooks
*check_trace
,
331 LttvHooks
*before_trace
,
332 LttvHooks
*after_trace
)
334 lttv_hooks_remove_list(tc
->check
, check_trace
);
335 lttv_hooks_remove_list(tc
->before
, before_trace
);
336 lttv_hooks_remove_list(tc
->after
, after_trace
);
339 void lttv_tracefile_context_add_hooks(LttvTracefileContext
*tfc
,
340 LttvHooks
*check_tracefile
,
341 LttvHooks
*before_tracefile
,
342 LttvHooks
*after_tracefile
,
343 LttvHooks
*check_event
,
344 LttvHooks
*before_event
,
345 LttvHooks
*after_event
)
347 lttv_hooks_add_list(tfc
->check
, check_tracefile
);
348 lttv_hooks_add_list(tfc
->before
, before_tracefile
);
349 lttv_hooks_add_list(tfc
->after
, after_tracefile
);
350 lttv_hooks_add_list(tfc
->check_event
, check_event
);
351 lttv_hooks_add_list(tfc
->before_event
, before_event
);
352 lttv_hooks_add_list(tfc
->after_event
, after_event
);
355 void lttv_tracefile_context_remove_hooks(LttvTracefileContext
*tfc
,
356 LttvHooks
*check_tracefile
,
357 LttvHooks
*before_tracefile
,
358 LttvHooks
*after_tracefile
,
359 LttvHooks
*check_event
,
360 LttvHooks
*before_event
,
361 LttvHooks
*after_event
)
363 lttv_hooks_remove_list(tfc
->check
, check_tracefile
);
364 lttv_hooks_remove_list(tfc
->before
, before_tracefile
);
365 lttv_hooks_remove_list(tfc
->after
, after_tracefile
);
366 lttv_hooks_remove_list(tfc
->check_event
, check_event
);
367 lttv_hooks_remove_list(tfc
->before_event
, before_event
);
368 lttv_hooks_remove_list(tfc
->after_event
, after_event
);
371 void lttv_tracefile_context_add_hooks_by_id(LttvTracefileContext
*tfc
,
373 LttvHooks
*before_event_by_id
,
374 LttvHooks
*after_event_by_id
)
377 h
= lttv_hooks_by_id_find(tfc
->before_event_by_id
, i
);
378 lttv_hooks_add_list(h
, before_event_by_id
);
379 h
= lttv_hooks_by_id_find(tfc
->after_event_by_id
, i
);
380 lttv_hooks_add_list(h
, after_event_by_id
);
383 void lttv_tracefile_context_remove_hooks_by_id(LttvTracefileContext
*tfc
,
386 lttv_hooks_by_id_remove(tfc
->before_event_by_id
, i
);
387 lttv_hooks_by_id_remove(tfc
->after_event_by_id
, i
);
390 static LttvTracesetContext
*
391 new_traceset_context(LttvTracesetContext
*self
)
393 return g_object_new(LTTV_TRACESET_CONTEXT_TYPE
, NULL
);
397 static LttvTraceContext
*
398 new_trace_context(LttvTracesetContext
*self
)
400 return g_object_new(LTTV_TRACE_CONTEXT_TYPE
, NULL
);
404 static LttvTracefileContext
*
405 new_tracefile_context(LttvTracesetContext
*self
)
407 return g_object_new(LTTV_TRACEFILE_CONTEXT_TYPE
, NULL
);
412 traceset_context_instance_init (GTypeInstance
*instance
, gpointer g_class
)
414 /* Be careful of anything which would not work well with shallow copies */
419 traceset_context_finalize (LttvTracesetContext
*self
)
421 G_OBJECT_CLASS(g_type_class_peek(g_type_parent(LTTV_TRACESET_CONTEXT_TYPE
)))
422 ->finalize(G_OBJECT(self
));
427 traceset_context_class_init (LttvTracesetContextClass
*klass
)
429 GObjectClass
*gobject_class
= G_OBJECT_CLASS(klass
);
431 gobject_class
->finalize
= (void (*)(GObject
*self
))traceset_context_finalize
;
434 klass
->new_traceset_context
= new_traceset_context
;
435 klass
->new_trace_context
= new_trace_context
;
436 klass
->new_tracefile_context
= new_tracefile_context
;
441 lttv_traceset_context_get_type(void)
443 static GType type
= 0;
445 static const GTypeInfo info
= {
446 sizeof (LttvTracesetContextClass
),
447 NULL
, /* base_init */
448 NULL
, /* base_finalize */
449 (GClassInitFunc
) traceset_context_class_init
, /* class_init */
450 NULL
, /* class_finalize */
451 NULL
, /* class_data */
452 sizeof (LttvTracesetContext
),
454 (GInstanceInitFunc
) traceset_context_instance_init
/* instance_init */
457 type
= g_type_register_static (G_TYPE_OBJECT
, "LttvTracesetContextType",
465 trace_context_instance_init (GTypeInstance
*instance
, gpointer g_class
)
467 /* Be careful of anything which would not work well with shallow copies */
472 trace_context_finalize (LttvTraceContext
*self
)
474 G_OBJECT_CLASS(g_type_class_peek(g_type_parent(LTTV_TRACE_CONTEXT_TYPE
)))->
475 finalize(G_OBJECT(self
));
480 trace_context_class_init (LttvTraceContextClass
*klass
)
482 GObjectClass
*gobject_class
= G_OBJECT_CLASS(klass
);
484 gobject_class
->finalize
= (void (*)(GObject
*self
)) trace_context_finalize
;
489 lttv_trace_context_get_type(void)
491 static GType type
= 0;
493 static const GTypeInfo info
= {
494 sizeof (LttvTraceContextClass
),
495 NULL
, /* base_init */
496 NULL
, /* base_finalize */
497 (GClassInitFunc
) trace_context_class_init
, /* class_init */
498 NULL
, /* class_finalize */
499 NULL
, /* class_data */
500 sizeof (LttvTraceContext
),
502 (GInstanceInitFunc
) trace_context_instance_init
/* instance_init */
505 type
= g_type_register_static (G_TYPE_OBJECT
, "LttvTraceContextType",
513 tracefile_context_instance_init (GTypeInstance
*instance
, gpointer g_class
)
515 /* Be careful of anything which would not work well with shallow copies */
520 tracefile_context_finalize (LttvTracefileContext
*self
)
522 G_OBJECT_CLASS(g_type_class_peek(g_type_parent(LTTV_TRACEFILE_CONTEXT_TYPE
)))
523 ->finalize(G_OBJECT(self
));
528 tracefile_context_class_init (LttvTracefileContextClass
*klass
)
530 GObjectClass
*gobject_class
= G_OBJECT_CLASS(klass
);
532 gobject_class
->finalize
= (void (*)(GObject
*self
))tracefile_context_finalize
;
537 lttv_tracefile_context_get_type(void)
539 static GType type
= 0;
541 static const GTypeInfo info
= {
542 sizeof (LttvTracefileContextClass
),
543 NULL
, /* base_init */
544 NULL
, /* base_finalize */
545 (GClassInitFunc
) tracefile_context_class_init
, /* class_init */
546 NULL
, /* class_finalize */
547 NULL
, /* class_data */
548 sizeof (LttvTracefileContext
),
550 (GInstanceInitFunc
) tracefile_context_instance_init
/* instance_init */
553 type
= g_type_register_static (G_TYPE_OBJECT
, "LttvTracefileContextType",
560 gint
compare_tracefile(gconstpointer a
, gconstpointer b
)
562 return ltt_time_compare(*((LttTime
*)a
), *((LttTime
*)b
));
566 gboolean
get_first(gpointer key
, gpointer value
, gpointer user_data
) {
567 *((LttvTracefileContext
**)user_data
) = (LttvTracefileContext
*)value
;
572 void lttv_process_traceset(LttvTracesetContext
*self
, LttTime end
,
573 unsigned maxNumEvents
)
575 GPtrArray
*traces
= g_ptr_array_new();
577 GPtrArray
*tracefiles
= g_ptr_array_new();
579 GTree
*pqueue
= g_tree_new(compare_tracefile
);
581 guint i
, j
, nbi
, nbj
, id
, nb_control
, nb_cpu
;
585 LttvTraceContext
*tc
;
587 LttTracefile
*tracefile
;
589 LttvTracefileContext
*tfc
;
595 LttTime previous_timestamp
= {0, 0};
597 /* Call all before_traceset, before_trace, and before_tracefile hooks.
598 For all qualifying tracefiles, seek to the start time, create a context,
599 read one event and insert in the pqueue based on the event time. */
601 lttv_hooks_call(self
->before
, self
);
602 nbi
= lttv_traceset_number(self
->ts
);
604 for(i
= 0 ; i
< nbi
; i
++) {
605 tc
= self
->traces
[i
];
608 if(!lttv_hooks_call_check(tc
->check
, tc
)) {
609 g_ptr_array_add(traces
, tc
);
610 lttv_hooks_call(tc
->before
, tc
);
611 nb_control
= ltt_trace_control_tracefile_number(trace
);
612 nb_cpu
= ltt_trace_per_cpu_tracefile_number(trace
);
613 nbj
= nb_control
+ nb_cpu
;
615 for(j
= 0 ; j
< nbj
; j
++) {
617 tfc
= tc
->control_tracefiles
[j
];
620 tfc
= tc
->per_cpu_tracefiles
[j
- nb_control
];
625 if(!lttv_hooks_call_check(tfc
->check
, tfc
)) {
626 g_ptr_array_add(tracefiles
, tfc
);
627 lttv_hooks_call(tfc
->before
, tfc
);
630 if(tfc
->timestamp
.tv_sec
< end
.tv_sec
||
631 (tfc
->timestamp
.tv_sec
== end
.tv_sec
&& tfc
->timestamp
.tv_nsec
<= end
.tv_nsec
)){
632 g_tree_insert(pqueue
, &(tfc
->timestamp
), tfc
);
640 /* Get the next event from the pqueue, call its hooks,
641 reinsert in the pqueue the following event from the same tracefile
642 unless the tracefile is finished or the event is later than the
647 g_tree_foreach(pqueue
, get_first
, &tfc
);
648 if(tfc
== NULL
) break;
650 /* Have we reached the maximum number of events specified? However,
651 continue for all the events with the same time stamp (CHECK?). Then,
652 empty the queue and break from the loop. */
655 if(count
> maxNumEvents
){
656 if(tfc
->timestamp
.tv_sec
== previous_timestamp
.tv_sec
&&
657 tfc
->timestamp
.tv_nsec
== previous_timestamp
.tv_nsec
) {
662 g_tree_foreach(pqueue
, get_first
, &tfc
);
663 if(tfc
== NULL
) break;
664 g_tree_remove(pqueue
, &(tfc
->timestamp
));
669 previous_timestamp
= tfc
->timestamp
;
672 /* Get the tracefile with an event for the smallest time found. If two
673 or more tracefiles have events for the same time, hope that lookup
674 and remove are consistent. */
676 tfc
= g_tree_lookup(pqueue
, &(tfc
->timestamp
));
677 g_tree_remove(pqueue
, &(tfc
->timestamp
));
679 if(!lttv_hooks_call(tfc
->check_event
, tfc
)) {
680 id
= ltt_event_eventtype_id(tfc
->e
);
681 lttv_hooks_call(tfc
->before_event
, tfc
);
682 lttv_hooks_call(lttv_hooks_by_id_get(tfc
->before_event_by_id
, id
), tfc
);
683 lttv_hooks_call(tfc
->after_event
, tfc
);
684 lttv_hooks_call(lttv_hooks_by_id_get(tfc
->after_event_by_id
, id
), tfc
);
687 event
= ltt_tracefile_read(tfc
->tf
);
690 tfc
->timestamp
= ltt_event_time(event
);
691 if(tfc
->timestamp
.tv_sec
< end
.tv_sec
||
692 (tfc
->timestamp
.tv_sec
== end
.tv_sec
&& tfc
->timestamp
.tv_nsec
<= end
.tv_nsec
))
693 g_tree_insert(pqueue
, &(tfc
->timestamp
), tfc
);
697 /* Call all the after_tracefile, after_trace and after_traceset hooks. */
699 for(i
= 0, j
= 0 ; i
< traces
->len
; i
++) {
700 tc
= traces
->pdata
[i
];
701 while(j
< tracefiles
->len
) {
702 tfc
= tracefiles
->pdata
[j
];
704 if(tfc
->t_context
== tc
) {
705 lttv_hooks_call(tfc
->after
, tfc
);
710 lttv_hooks_call(tc
->after
, tc
);
713 g_assert(j
== tracefiles
->len
);
714 lttv_hooks_call(self
->after
, self
);
716 /* Free the traces, tracefiles and pqueue */
718 g_ptr_array_free(tracefiles
, TRUE
);
719 g_ptr_array_free(traces
, TRUE
);
720 g_tree_destroy(pqueue
);
724 void lttv_process_trace_seek_time(LttvTraceContext
*self
, LttTime start
)
726 guint i
, nb_control
, nb_per_cpu
, nb_tracefile
;
728 LttvTracefileContext
*tfc
;
732 nb_control
= ltt_trace_control_tracefile_number(self
->t
);
733 nb_per_cpu
= ltt_trace_per_cpu_tracefile_number(self
->t
);
734 nb_tracefile
= nb_control
+ nb_per_cpu
;
735 for(i
= 0 ; i
< nb_tracefile
; i
++) {
736 if(i
< nb_control
) tfc
= self
->control_tracefiles
[i
];
737 else tfc
= self
->per_cpu_tracefiles
[i
- nb_control
];
739 ltt_tracefile_seek_time(tfc
->tf
, start
);
740 event
= ltt_tracefile_read(tfc
->tf
);
742 if(event
!= NULL
) tfc
->timestamp
= ltt_event_time(event
);
747 void lttv_process_traceset_seek_time(LttvTracesetContext
*self
, LttTime start
)
751 LttvTraceContext
*tc
;
753 nb_trace
= lttv_traceset_number(self
->ts
);
754 for(i
= 0 ; i
< nb_trace
; i
++) {
755 tc
= self
->traces
[i
];
756 lttv_process_trace_seek_time(tc
, start
);
762 find_field(LttEventType
*et
, const char *field
)
772 if(field
== NULL
) return NULL
;
774 f
= ltt_eventtype_field(et
);
775 t
= ltt_eventtype_type(et
);
776 g_assert(ltt_type_class(t
) == LTT_STRUCT
);
777 nb
= ltt_type_member_number(t
);
778 for(i
= 0 ; i
< nb
; i
++) {
779 ltt_type_member_type(t
, i
, &name
);
780 if(strcmp(name
, field
) == 0) break;
783 return ltt_field_member(f
, i
);
788 lttv_trace_find_hook(LttTrace
*t
, char *facility
, char *event_type
,
789 char *field1
, char *field2
, char *field3
, LttvHook h
, LttvTraceHook
*th
)
799 nb
= ltt_trace_facility_find(t
, facility
, &pos
);
800 if(nb
< 1) g_error("No %s facility", facility
);
801 f
= ltt_trace_facility_get(t
, pos
);
802 et
= ltt_facility_eventtype_get_by_name(f
, event_type
);
803 if(et
== NULL
) g_error("Event %s does not exist", event_type
);
806 th
->id
= ltt_eventtype_id(et
);
807 th
->f1
= find_field(et
, field1
);
808 th
->f2
= find_field(et
, field2
);
809 th
->f3
= find_field(et
, field3
);