2 #include <lttv/stats.h>
3 #include <ltt/facility.h>
8 LTTV_STATS_PROCESS_UNKNOWN
,
11 LTTV_STATS_MODE_TYPES
,
14 LTTV_STATS_EVENT_TYPES
,
16 LTTV_STATS_ELAPSED_TIME
,
18 LTTV_STATS_EVENTS_COUNT
;
21 LTTV_STATS_BEFORE_HOOKS
,
22 LTTV_STATS_AFTER_HOOKS
;
24 static void remove_all_processes(GHashTable
*processes
);
27 find_event_tree(LttvTracefileStats
*tfcs
, GQuark process
, GQuark cpu
,
28 GQuark mode
, GQuark sub_mode
, LttvAttribute
**events_tree
,
29 LttvAttribute
**event_types_tree
);
32 init(LttvTracesetStats
*self
, LttvTraceset
*ts
)
34 guint i
, j
, nb_trace
, nb_control
, nb_per_cpu
, nb_tracefile
;
40 LttvTracefileContext
*tfc
;
42 LttvTracefileStats
*tfcs
;
44 LttTime timestamp
= {0,0};
46 LTTV_TRACESET_CONTEXT_CLASS(g_type_class_peek(LTTV_TRACESET_STATE_TYPE
))->
47 init((LttvTracesetContext
*)self
, ts
);
49 self
->stats
= g_object_new(LTTV_ATTRIBUTE_TYPE
, NULL
);
50 nb_trace
= lttv_traceset_number(ts
);
52 for(i
= 0 ; i
< nb_trace
; i
++) {
53 tcs
= (LttvTraceStats
*)tc
= (LTTV_TRACESET_CONTEXT(self
)->traces
[i
]);
54 tcs
->stats
= g_object_new(LTTV_ATTRIBUTE_TYPE
, NULL
);
56 nb_control
= ltt_trace_control_tracefile_number(tc
->t
);
57 nb_per_cpu
= ltt_trace_per_cpu_tracefile_number(tc
->t
);
58 nb_tracefile
= nb_control
+ nb_per_cpu
;
59 for(j
= 0 ; j
< nb_tracefile
; j
++) {
61 tfcs
= LTTV_TRACEFILE_STATS(tc
->control_tracefiles
[j
]);
64 tfcs
= LTTV_TRACEFILE_STATS(tc
->per_cpu_tracefiles
[j
- nb_control
]);
67 tfcs
->stats
= g_object_new(LTTV_ATTRIBUTE_TYPE
, NULL
);
68 find_event_tree(tfcs
, LTTV_STATS_PROCESS_UNKNOWN
,
69 tfcs
->parent
.cpu_name
, LTTV_STATE_MODE_UNKNOWN
,
70 LTTV_STATE_SUBMODE_UNKNOWN
, &tfcs
->current_events_tree
,
71 &tfcs
->current_event_types_tree
);
78 fini(LttvTracesetStats
*self
)
80 guint i
, j
, nb_trace
, nb_tracefile
;
88 LttvTracefileContext
*tfc
;
90 LttvTracefileStats
*tfcs
;
92 LttTime timestamp
= {0,0};
94 lttv_attribute_recursive_free(self
->stats
);
95 ts
= self
->parent
.parent
.ts
;
96 nb_trace
= lttv_traceset_number(ts
);
98 for(i
= 0 ; i
< nb_trace
; i
++) {
99 tcs
= (LttvTraceStats
*)tc
= (LTTV_TRACESET_CONTEXT(self
)->traces
[i
]);
100 lttv_attribute_recursive_free(tcs
->stats
);
102 nb_tracefile
= ltt_trace_control_tracefile_number(tc
->t
);
103 for(j
= 0 ; j
< nb_tracefile
; j
++) {
104 tfcs
= (LttvTracefileStats
*)tfc
= tc
->control_tracefiles
[j
];
105 lttv_attribute_recursive_free(tfcs
->stats
);
106 tfcs
->current_events_tree
= NULL
;
107 tfcs
->current_event_types_tree
= NULL
;
110 nb_tracefile
= ltt_trace_per_cpu_tracefile_number(tc
->t
);
111 for(j
= 0 ; j
< nb_tracefile
; j
++) {
112 tfcs
= (LttvTracefileStats
*)tfc
= tc
->per_cpu_tracefiles
[j
];
113 lttv_attribute_recursive_free(tfcs
->stats
);
114 tfcs
->current_events_tree
= NULL
;
115 tfcs
->current_event_types_tree
= NULL
;
118 LTTV_TRACESET_CONTEXT_CLASS(g_type_class_peek(LTTV_TRACESET_STATE_TYPE
))->
119 fini((LttvTracesetContext
*)self
);
123 static LttvTracesetContext
*
124 new_traceset_context(LttvTracesetContext
*self
)
126 return LTTV_TRACESET_CONTEXT(g_object_new(LTTV_TRACESET_STATS_TYPE
, NULL
));
130 static LttvTraceContext
*
131 new_trace_context(LttvTracesetContext
*self
)
133 return LTTV_TRACE_CONTEXT(g_object_new(LTTV_TRACE_STATS_TYPE
, NULL
));
137 static LttvTracefileContext
*
138 new_tracefile_context(LttvTracesetContext
*self
)
140 return LTTV_TRACEFILE_CONTEXT(g_object_new(LTTV_TRACEFILE_STATS_TYPE
, NULL
));
145 traceset_stats_instance_init (GTypeInstance
*instance
, gpointer g_class
)
151 traceset_stats_finalize (LttvTracesetStats
*self
)
153 G_OBJECT_CLASS(g_type_class_peek(LTTV_TRACESET_STATE_TYPE
))->
154 finalize(G_OBJECT(self
));
159 traceset_stats_class_init (LttvTracesetContextClass
*klass
)
161 GObjectClass
*gobject_class
= G_OBJECT_CLASS(klass
);
163 gobject_class
->finalize
= (void (*)(GObject
*self
)) traceset_stats_finalize
;
164 klass
->init
= (void (*)(LttvTracesetContext
*self
, LttvTraceset
*ts
))init
;
165 klass
->fini
= (void (*)(LttvTracesetContext
*self
))fini
;
166 klass
->new_traceset_context
= new_traceset_context
;
167 klass
->new_trace_context
= new_trace_context
;
168 klass
->new_tracefile_context
= new_tracefile_context
;
173 lttv_traceset_stats_get_type(void)
175 static GType type
= 0;
177 static const GTypeInfo info
= {
178 sizeof (LttvTracesetStatsClass
),
179 NULL
, /* base_init */
180 NULL
, /* base_finalize */
181 (GClassInitFunc
) traceset_stats_class_init
, /* class_init */
182 NULL
, /* class_finalize */
183 NULL
, /* class_data */
184 sizeof (LttvTracesetContext
),
186 (GInstanceInitFunc
) traceset_stats_instance_init
/* instance_init */
189 type
= g_type_register_static (LTTV_TRACESET_STATE_TYPE
, "LttvTracesetStatsType",
197 trace_stats_instance_init (GTypeInstance
*instance
, gpointer g_class
)
203 trace_stats_finalize (LttvTraceStats
*self
)
205 G_OBJECT_CLASS(g_type_class_peek(LTTV_TRACE_STATE_TYPE
))->
206 finalize(G_OBJECT(self
));
211 trace_stats_class_init (LttvTraceContextClass
*klass
)
213 GObjectClass
*gobject_class
= G_OBJECT_CLASS(klass
);
215 gobject_class
->finalize
= (void (*)(GObject
*self
)) trace_stats_finalize
;
220 lttv_trace_stats_get_type(void)
222 static GType type
= 0;
224 static const GTypeInfo info
= {
225 sizeof (LttvTraceStatsClass
),
226 NULL
, /* base_init */
227 NULL
, /* base_finalize */
228 (GClassInitFunc
) trace_stats_class_init
, /* class_init */
229 NULL
, /* class_finalize */
230 NULL
, /* class_data */
231 sizeof (LttvTraceStats
),
233 (GInstanceInitFunc
) trace_stats_instance_init
/* instance_init */
236 type
= g_type_register_static (LTTV_TRACE_STATE_TYPE
,
237 "LttvTraceStatsType", &info
, 0);
244 tracefile_stats_instance_init (GTypeInstance
*instance
, gpointer g_class
)
250 tracefile_stats_finalize (LttvTracefileStats
*self
)
252 G_OBJECT_CLASS(g_type_class_peek(LTTV_TRACEFILE_STATE_TYPE
))->
253 finalize(G_OBJECT(self
));
258 tracefile_stats_class_init (LttvTracefileStatsClass
*klass
)
260 GObjectClass
*gobject_class
= G_OBJECT_CLASS(klass
);
262 gobject_class
->finalize
= (void (*)(GObject
*self
)) tracefile_stats_finalize
;
267 lttv_tracefile_stats_get_type(void)
269 static GType type
= 0;
271 static const GTypeInfo info
= {
272 sizeof (LttvTracefileStatsClass
),
273 NULL
, /* base_init */
274 NULL
, /* base_finalize */
275 (GClassInitFunc
) tracefile_stats_class_init
, /* class_init */
276 NULL
, /* class_finalize */
277 NULL
, /* class_data */
278 sizeof (LttvTracefileStats
),
280 (GInstanceInitFunc
) tracefile_stats_instance_init
/* instance_init */
283 type
= g_type_register_static (LTTV_TRACEFILE_STATE_TYPE
,
284 "LttvTracefileStatsType", &info
, 0);
291 find_event_tree(LttvTracefileStats
*tfcs
, GQuark process
, GQuark cpu
,
292 GQuark mode
, GQuark sub_mode
, LttvAttribute
**events_tree
,
293 LttvAttribute
**event_types_tree
)
297 LttvTraceStats
*tcs
= LTTV_TRACE_STATS(tfcs
->parent
.parent
.t_context
);
298 a
= lttv_attribute_find_subdir(tcs
->stats
, LTTV_STATS_PROCESSES
);
299 a
= lttv_attribute_find_subdir(a
, tfcs
->parent
.process
->pid_time
);
300 a
= lttv_attribute_find_subdir(a
, LTTV_STATS_CPU
);
301 a
= lttv_attribute_find_subdir(a
, tfcs
->parent
.cpu_name
);
302 a
= lttv_attribute_find_subdir(a
, LTTV_STATS_MODE_TYPES
);
303 a
= lttv_attribute_find_subdir(a
, tfcs
->parent
.process
->state
->t
);
304 a
= lttv_attribute_find_subdir(a
, LTTV_STATS_SUBMODES
);
305 a
= lttv_attribute_find_subdir(a
, tfcs
->parent
.process
->state
->n
);
307 a
= lttv_attribute_find_subdir(a
, LTTV_STATS_EVENT_TYPES
);
308 *event_types_tree
= a
;
312 static void update_event_tree(LttvTracefileStats
*tfcs
)
314 LttvExecutionState
*es
= tfcs
->parent
.process
->state
;
316 find_event_tree(tfcs
, tfcs
->parent
.process
->pid_time
, tfcs
->parent
.cpu_name
,
317 es
->t
, es
->n
, &(tfcs
->current_events_tree
),
318 &(tfcs
->current_event_types_tree
));
322 static void mode_change(LttvTracefileStats
*tfcs
)
324 LttvAttributeValue cpu_time
;
328 lttv_attribute_find(tfcs
->current_events_tree
, LTTV_STATS_CPU_TIME
,
329 LTTV_TIME
, &cpu_time
);
330 TimeSub(delta
, tfcs
->parent
.parent
.timestamp
,
331 tfcs
->parent
.process
->state
->change
);
332 TimeAdd(*(cpu_time
.v_time
), *(cpu_time
.v_time
), delta
);
336 static void mode_end(LttvTracefileStats
*tfcs
)
338 LttvAttributeValue elapsed_time
, cpu_time
;
342 lttv_attribute_find(tfcs
->current_events_tree
, LTTV_STATS_ELAPSED_TIME
,
343 LTTV_TIME
, &elapsed_time
);
344 TimeSub(delta
, tfcs
->parent
.parent
.timestamp
,
345 tfcs
->parent
.process
->state
->entry
);
346 TimeAdd(*(elapsed_time
.v_time
), *(elapsed_time
.v_time
), delta
);
348 lttv_attribute_find(tfcs
->current_events_tree
, LTTV_STATS_CPU_TIME
,
349 LTTV_TIME
, &cpu_time
);
350 TimeSub(delta
, tfcs
->parent
.parent
.timestamp
,
351 tfcs
->parent
.process
->state
->change
);
352 TimeAdd(*(cpu_time
.v_time
), *(cpu_time
.v_time
), delta
);
356 static gboolean
before_syscall_entry(void *hook_data
, void *call_data
)
358 mode_change((LttvTracefileStats
*)call_data
);
363 static gboolean
after_syscall_entry(void *hook_data
, void *call_data
)
365 update_event_tree((LttvTracefileStats
*)call_data
);
370 gboolean
before_syscall_exit(void *hook_data
, void *call_data
)
372 mode_end((LttvTracefileStats
*)call_data
);
377 static gboolean
after_syscall_exit(void *hook_data
, void *call_data
)
379 update_event_tree((LttvTracefileStats
*)call_data
);
384 gboolean
before_trap_entry(void *hook_data
, void *call_data
)
386 mode_change((LttvTracefileStats
*)call_data
);
391 static gboolean
after_trap_entry(void *hook_data
, void *call_data
)
393 update_event_tree((LttvTracefileStats
*)call_data
);
398 gboolean
before_trap_exit(void *hook_data
, void *call_data
)
400 mode_end((LttvTracefileStats
*)call_data
);
405 gboolean
after_trap_exit(void *hook_data
, void *call_data
)
407 update_event_tree((LttvTracefileStats
*)call_data
);
412 gboolean
before_irq_entry(void *hook_data
, void *call_data
)
414 mode_change((LttvTracefileStats
*)call_data
);
419 gboolean
after_irq_entry(void *hook_data
, void *call_data
)
421 update_event_tree((LttvTracefileStats
*)call_data
);
426 gboolean
before_irq_exit(void *hook_data
, void *call_data
)
428 mode_end((LttvTracefileStats
*)call_data
);
433 gboolean
after_irq_exit(void *hook_data
, void *call_data
)
435 update_event_tree((LttvTracefileStats
*)call_data
);
440 gboolean
before_schedchange(void *hook_data
, void *call_data
)
442 LttvTraceHook
*h
= (LttvTraceHook
*)hook_data
;
444 LttvTracefileStats
*tfcs
= (LttvTracefileStats
*)call_data
;
446 guint pid_in
, pid_out
, state_out
;
448 LttvProcessState
*process
;
450 pid_in
= ltt_event_get_unsigned(tfcs
->parent
.parent
.e
, h
->f1
);
451 pid_out
= ltt_event_get_unsigned(tfcs
->parent
.parent
.e
, h
->f2
);
452 state_out
= ltt_event_get_unsigned(tfcs
->parent
.parent
.e
, h
->f3
);
454 /* compute the time for the process to schedule out */
458 /* get the information for the process scheduled in */
460 process
= lttv_state_find_process(&(tfcs
->parent
), pid_in
);
462 find_event_tree(tfcs
, process
->pid_time
, tfcs
->parent
.cpu_name
,
463 process
->state
->t
, process
->state
->n
, &(tfcs
->current_events_tree
),
464 &(tfcs
->current_event_types_tree
));
466 /* compute the time waiting for the process to schedule in */
473 gboolean
process_fork(void *hook_data
, void *call_data
)
475 /* nothing to do for now */
480 gboolean
process_exit(void *hook_data
, void *call_data
)
482 /* We should probably exit all modes here or we could do that at
488 gboolean
every_event(void *hook_data
, void *call_data
)
490 LttvTracefileStats
*tfcs
= (LttvTracefileStats
*)call_data
;
492 LttvAttributeValue v
;
494 /* The current branch corresponds to the tracefile/process/interrupt state.
495 Statistics are added within it, to count the number of events of this
496 type occuring in this context. A quark has been pre-allocated for each
497 event type and is used as name. */
499 lttv_attribute_find(tfcs
->current_event_types_tree
,
500 ((LttvTraceState
*)(tfcs
->parent
.parent
.t_context
))->
501 eventtype_names
[ltt_event_eventtype_id(tfcs
->parent
.parent
.e
)],
509 sum_stats(void *hook_data
, void *call_data
)
511 LttvTracesetStats
*tscs
= (LttvTracesetStats
*)call_data
;
515 LttvTraceset
*traceset
= tscs
->parent
.parent
.ts
;
517 LttvAttributeType type
;
519 LttvAttributeValue value
;
521 LttvAttributeName name
;
525 int i
, j
, k
, l
, m
, n
, nb_trace
, nb_process
, nb_cpu
, nb_mode_type
, nb_submode
,
528 LttvAttribute
*main_tree
, *processes_tree
, *process_tree
, *cpus_tree
,
529 *cpu_tree
, *mode_tree
, *mode_types_tree
, *submodes_tree
,
530 *submode_tree
, *event_types_tree
, *mode_events_tree
,
531 *cpu_events_tree
, *process_modes_tree
, *trace_cpu_tree
,
532 *trace_modes_tree
, *traceset_modes_tree
;
534 traceset_modes_tree
= lttv_attribute_find_subdir(tscs
->stats
,
536 nb_trace
= lttv_traceset_number(traceset
);
538 for(i
= 0 ; i
< nb_trace
; i
++) {
539 tcs
= (LttvTraceStats
*)(tscs
->parent
.parent
.traces
[i
]);
540 main_tree
= tcs
->stats
;
541 processes_tree
= lttv_attribute_find_subdir(main_tree
,
542 LTTV_STATS_PROCESSES
);
543 trace_modes_tree
= lttv_attribute_find_subdir(main_tree
, LTTV_STATS_MODES
);
544 nb_process
= lttv_attribute_get_number(processes_tree
);
546 for(j
= 0 ; j
< nb_process
; j
++) {
547 type
= lttv_attribute_get(processes_tree
, j
, &name
, &value
);
548 process_tree
= LTTV_ATTRIBUTE(*(value
.v_gobject
));
550 cpus_tree
= lttv_attribute_find_subdir(process_tree
, LTTV_STATS_CPU
);
551 process_modes_tree
= lttv_attribute_find_subdir(process_tree
,
553 nb_cpu
= lttv_attribute_get_number(cpus_tree
);
555 for(k
= 0 ; k
< nb_cpu
; k
++) {
556 type
= lttv_attribute_get(cpus_tree
, k
, &name
, &value
);
557 cpu_tree
= LTTV_ATTRIBUTE(*(value
.v_gobject
));
559 mode_types_tree
= lttv_attribute_find_subdir(cpu_tree
,
560 LTTV_STATS_MODE_TYPES
);
561 cpu_events_tree
= lttv_attribute_find_subdir(cpu_tree
,
563 trace_cpu_tree
= lttv_attribute_find_subdir(main_tree
, LTTV_STATS_CPU
);
564 trace_cpu_tree
= lttv_attribute_find_subdir(trace_cpu_tree
, name
);
565 nb_mode_type
= lttv_attribute_get_number(mode_types_tree
);
567 for(l
= 0 ; l
< nb_mode_type
; l
++) {
568 type
= lttv_attribute_get(mode_types_tree
, l
, &name
, &value
);
569 mode_tree
= LTTV_ATTRIBUTE(*(value
.v_gobject
));
571 submodes_tree
= lttv_attribute_find_subdir(mode_tree
,
572 LTTV_STATS_SUBMODES
);
573 mode_events_tree
= lttv_attribute_find_subdir(mode_tree
,
575 nb_submode
= lttv_attribute_get_number(submodes_tree
);
577 for(m
= 0 ; m
< nb_submode
; m
++) {
578 type
= lttv_attribute_get(submodes_tree
, m
, &name
, &value
);
579 submode_tree
= LTTV_ATTRIBUTE(*(value
.v_gobject
));
581 event_types_tree
= lttv_attribute_find_subdir(submode_tree
,
582 LTTV_STATS_EVENT_TYPES
);
583 nb_event_type
= lttv_attribute_get_number(event_types_tree
);
586 for(n
= 0 ; n
< nb_event_type
; n
++) {
587 type
= lttv_attribute_get(event_types_tree
, n
, &name
, &value
);
588 sum
+= *(value
.v_uint
);
590 lttv_attribute_find(submode_tree
, LTTV_STATS_EVENTS_COUNT
,
592 *(value
.v_uint
) = sum
;
593 lttv_attribute_recursive_add(mode_events_tree
, submode_tree
);
595 lttv_attribute_recursive_add(cpu_events_tree
, mode_events_tree
);
597 lttv_attribute_recursive_add(process_modes_tree
, cpu_tree
);
598 lttv_attribute_recursive_add(trace_cpu_tree
, cpu_tree
);
600 lttv_attribute_recursive_add(trace_modes_tree
, process_modes_tree
);
602 lttv_attribute_recursive_add(traceset_modes_tree
, trace_modes_tree
);
608 lttv_stats_add_event_hooks(LttvTracesetStats
*self
)
610 LttvTraceset
*traceset
= self
->parent
.parent
.ts
;
612 guint i
, j
, k
, nb_trace
, nb_control
, nb_per_cpu
, nb_tracefile
;
620 LttvTracefileStats
*tfs
;
624 GArray
*hooks
, *before_hooks
, *after_hooks
;
628 LttvAttributeValue val
;
630 nb_trace
= lttv_traceset_number(traceset
);
631 for(i
= 0 ; i
< nb_trace
; i
++) {
632 ts
= (LttvTraceStats
*)self
->parent
.parent
.traces
[i
];
634 /* Find the eventtype id for the following events and register the
635 associated by id hooks. */
637 hooks
= g_array_new(FALSE
, FALSE
, sizeof(LttvTraceHook
));
638 g_array_set_size(hooks
, 7);
640 lttv_trace_find_hook(ts
->parent
.parent
.t
, "core","syscall_entry",
641 "syscall_id", NULL
, NULL
, before_syscall_entry
,
642 &g_array_index(hooks
, LttvTraceHook
, 0));
644 lttv_trace_find_hook(ts
->parent
.parent
.t
, "core", "syscall_exit", NULL
,
645 NULL
, NULL
, before_syscall_exit
,
646 &g_array_index(hooks
, LttvTraceHook
, 1));
648 lttv_trace_find_hook(ts
->parent
.parent
.t
, "core", "trap_entry", "trap_id",
649 NULL
, NULL
, before_trap_entry
,
650 &g_array_index(hooks
, LttvTraceHook
, 2));
652 lttv_trace_find_hook(ts
->parent
.parent
.t
, "core", "trap_exit", NULL
, NULL
,
653 NULL
, before_trap_exit
, &g_array_index(hooks
, LttvTraceHook
, 3));
655 lttv_trace_find_hook(ts
->parent
.parent
.t
, "core", "irq_entry", "irq_id",
656 NULL
, NULL
, before_irq_entry
, &g_array_index(hooks
, LttvTraceHook
, 4));
658 lttv_trace_find_hook(ts
->parent
.parent
.t
, "core", "irq_exit", NULL
, NULL
,
659 NULL
, before_irq_exit
, &g_array_index(hooks
, LttvTraceHook
, 5));
661 lttv_trace_find_hook(ts
->parent
.parent
.t
, "core", "schedchange", "in",
662 "out", "out_state", before_schedchange
,
663 &g_array_index(hooks
, LttvTraceHook
, 6));
665 before_hooks
= hooks
;
667 hooks
= g_array_new(FALSE
, FALSE
, sizeof(LttvTraceHook
));
668 g_array_set_size(hooks
, 8);
670 lttv_trace_find_hook(ts
->parent
.parent
.t
, "core","syscall_entry",
671 "syscall_id", NULL
, NULL
, after_syscall_entry
,
672 &g_array_index(hooks
, LttvTraceHook
, 0));
674 lttv_trace_find_hook(ts
->parent
.parent
.t
, "core", "syscall_exit", NULL
,
675 NULL
, NULL
, after_syscall_exit
,
676 &g_array_index(hooks
, LttvTraceHook
, 1));
678 lttv_trace_find_hook(ts
->parent
.parent
.t
, "core", "trap_entry", "trap_id",
679 NULL
, NULL
, after_trap_entry
, &g_array_index(hooks
, LttvTraceHook
, 2));
681 lttv_trace_find_hook(ts
->parent
.parent
.t
, "core", "trap_exit", NULL
, NULL
,
682 NULL
, after_trap_exit
, &g_array_index(hooks
, LttvTraceHook
, 3));
684 lttv_trace_find_hook(ts
->parent
.parent
.t
, "core", "irq_entry", "irq_id",
685 NULL
, NULL
, after_irq_entry
, &g_array_index(hooks
, LttvTraceHook
, 4));
687 lttv_trace_find_hook(ts
->parent
.parent
.t
, "core", "irq_exit", NULL
, NULL
,
688 NULL
, after_irq_exit
, &g_array_index(hooks
, LttvTraceHook
, 5));
690 lttv_trace_find_hook(ts
->parent
.parent
.t
, "core", "process_fork",
691 "child_pid", NULL
, NULL
, process_fork
,
692 &g_array_index(hooks
, LttvTraceHook
, 6));
694 lttv_trace_find_hook(ts
->parent
.parent
.t
, "core", "process_exit", NULL
,
695 NULL
, NULL
, process_exit
, &g_array_index(hooks
, LttvTraceHook
, 7));
699 /* Add these hooks to each before_event_by_id hooks list */
701 nb_control
= ltt_trace_control_tracefile_number(ts
->parent
.parent
.t
);
702 nb_per_cpu
= ltt_trace_per_cpu_tracefile_number(ts
->parent
.parent
.t
);
703 nb_tracefile
= nb_control
+ nb_per_cpu
;
704 for(j
= 0 ; j
< nb_tracefile
; j
++) {
706 tfs
= LTTV_TRACEFILE_STATS(ts
->parent
.parent
.control_tracefiles
[j
]);
709 tfs
= LTTV_TRACEFILE_STATS(ts
->parent
.parent
.per_cpu_tracefiles
[
713 lttv_hooks_add(tfs
->parent
.parent
.after_event
, every_event
, NULL
);
715 for(k
= 0 ; k
< before_hooks
->len
; k
++) {
716 hook
= g_array_index(before_hooks
, LttvTraceHook
, k
);
717 lttv_hooks_add(lttv_hooks_by_id_find(
718 tfs
->parent
.parent
.before_event_by_id
,
719 hook
.id
), hook
.h
, &g_array_index(before_hooks
, LttvTraceHook
, k
));
721 for(k
= 0 ; k
< after_hooks
->len
; k
++) {
722 hook
= g_array_index(after_hooks
, LttvTraceHook
, k
);
723 lttv_hooks_add(lttv_hooks_by_id_find(
724 tfs
->parent
.parent
.after_event_by_id
,
725 hook
.id
), hook
.h
, &g_array_index(after_hooks
, LttvTraceHook
, k
));
728 lttv_attribute_find(self
->parent
.parent
.a
, LTTV_STATS_BEFORE_HOOKS
,
730 *(val
.v_pointer
) = before_hooks
;
731 lttv_attribute_find(self
->parent
.parent
.a
, LTTV_STATS_AFTER_HOOKS
,
733 *(val
.v_pointer
) = after_hooks
;
735 lttv_hooks_add(self
->parent
.parent
.after
, sum_stats
, NULL
);
739 lttv_stats_remove_event_hooks(LttvTracesetStats
*self
)
741 LttvTraceset
*traceset
= self
->parent
.parent
.ts
;
743 guint i
, j
, k
, nb_trace
, nb_control
, nb_per_cpu
, nb_tracefile
;
747 LttvTracefileStats
*tfs
;
751 GArray
*before_hooks
, *after_hooks
;
755 LttvAttributeValue val
;
757 nb_trace
= lttv_traceset_number(traceset
);
758 for(i
= 0 ; i
< nb_trace
; i
++) {
759 ts
= LTTV_TRACE_STATS(self
->parent
.parent
.traces
[i
]);
760 lttv_attribute_find(self
->parent
.parent
.a
, LTTV_STATS_BEFORE_HOOKS
,
762 before_hooks
= *(val
.v_pointer
);
763 lttv_attribute_find(self
->parent
.parent
.a
, LTTV_STATS_AFTER_HOOKS
,
765 after_hooks
= *(val
.v_pointer
);
767 /* Add these hooks to each before_event_by_id hooks list */
769 nb_control
= ltt_trace_control_tracefile_number(ts
->parent
.parent
.t
);
770 nb_per_cpu
= ltt_trace_per_cpu_tracefile_number(ts
->parent
.parent
.t
);
771 nb_tracefile
= nb_control
+ nb_per_cpu
;
772 for(j
= 0 ; j
< nb_tracefile
; j
++) {
774 tfs
= LTTV_TRACEFILE_STATS(ts
->parent
.parent
.control_tracefiles
[j
]);
777 tfs
=LTTV_TRACEFILE_STATS(ts
->parent
.parent
.per_cpu_tracefiles
[
781 lttv_hooks_remove_data(tfs
->parent
.parent
.after_event
, every_event
,
784 for(k
= 0 ; k
< before_hooks
->len
; k
++) {
785 hook
= g_array_index(before_hooks
, LttvTraceHook
, k
);
786 lttv_hooks_remove_data(
787 lttv_hooks_by_id_find(tfs
->parent
.parent
.before_event_by_id
,
788 hook
.id
), hook
.h
, &g_array_index(before_hooks
, LttvTraceHook
, k
));
790 for(k
= 0 ; k
< after_hooks
->len
; k
++) {
791 hook
= g_array_index(after_hooks
, LttvTraceHook
, k
);
792 lttv_hooks_remove_data(
793 lttv_hooks_by_id_find(tfs
->parent
.parent
.after_event_by_id
,
794 hook
.id
), hook
.h
, &g_array_index(after_hooks
, LttvTraceHook
, k
));
797 g_critical("lttv_stats_remove_event_hooks()");
798 g_array_free(before_hooks
, TRUE
);
799 g_array_free(after_hooks
, TRUE
);
801 lttv_hooks_remove_data(self
->parent
.parent
.after
, sum_stats
, NULL
);
805 void lttv_stats_init(int argc
, char **argv
)
807 LTTV_STATS_PROCESS_UNKNOWN
= g_quark_from_string("unknown process");
808 LTTV_STATS_PROCESSES
= g_quark_from_string("processes");
809 LTTV_STATS_CPU
= g_quark_from_string("cpu");
810 LTTV_STATS_MODE_TYPES
= g_quark_from_string("mode_types");
811 LTTV_STATS_MODES
= g_quark_from_string("modes");
812 LTTV_STATS_SUBMODES
= g_quark_from_string("submodes");
813 LTTV_STATS_EVENT_TYPES
= g_quark_from_string("event_types");
814 LTTV_STATS_CPU_TIME
= g_quark_from_string("cpu time");
815 LTTV_STATS_ELAPSED_TIME
= g_quark_from_string("elapsed time");
816 LTTV_STATS_EVENTS
= g_quark_from_string("events");
817 LTTV_STATS_EVENTS_COUNT
= g_quark_from_string("events count");
818 LTTV_STATS_BEFORE_HOOKS
= g_quark_from_string("saved stats before hooks");
819 LTTV_STATS_AFTER_HOOKS
= g_quark_from_string("saved stats after hooks");
822 void lttv_stats_destroy()