1 /* This file is part of the Linux Trace Toolkit viewer
2 * Copyright (C) 2003-2004 Michel Dagenais
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;
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.
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,
24 #include <lttv/module.h>
25 #include <lttv/stats.h>
26 #include <lttv/lttv.h>
27 #include <lttv/attribute.h>
28 #include <ltt/trace.h>
29 #include <ltt/event.h>
32 #define MAX_64_HEX_STRING_LEN 19
35 LTTV_STATS_PROCESS_UNKNOWN
,
38 LTTV_STATS_MODE_TYPES
,
42 LTTV_STATS_EVENT_TYPES
,
44 LTTV_STATS_CUMULATIVE_CPU_TIME
,
45 LTTV_STATS_ELAPSED_TIME
,
47 LTTV_STATS_EVENTS_COUNT
,
50 LTTV_STATS_TRACEFILES
,
52 LTTV_STATS_BEFORE_HOOKS
,
53 LTTV_STATS_AFTER_HOOKS
;
56 find_event_tree(LttvTracefileStats
*tfcs
, GQuark pid_time
, guint cpu
,
58 GQuark mode
, GQuark sub_mode
, LttvAttribute
**events_tree
,
59 LttvAttribute
**event_types_tree
);
62 static void lttv_stats_init(LttvTracesetStats
*self
)
64 guint i
, j
, nb_trace
, nb_tracefile
;
70 LttvTracefileContext
**tfs
;
71 LttvTracefileStats
*tfcs
;
75 LttvAttribute
*tracefiles_stats
;
77 LttvTraceset
*ts
= self
->parent
.parent
.ts
;
79 self
->stats
= lttv_attribute_find_subdir(
80 lttv_traceset_attribute(self
->parent
.parent
.ts
),
82 lttv_attribute_find(lttv_traceset_attribute(self
->parent
.parent
.ts
),
87 if(*(v
.v_uint
) == 1) {
88 g_assert(lttv_attribute_get_number(self
->stats
) == 0);
91 nb_trace
= lttv_traceset_number(ts
);
93 for(i
= 0 ; i
< nb_trace
; i
++) {
94 tc
= self
->parent
.parent
.traces
[i
];
95 tcs
= LTTV_TRACE_STATS(tc
);
97 tcs
->stats
= lttv_attribute_find_subdir(tcs
->parent
.parent
.t_a
,LTTV_STATS
);
98 tracefiles_stats
= lttv_attribute_find_subdir(tcs
->parent
.parent
.t_a
,
99 LTTV_STATS_TRACEFILES
);
100 lttv_attribute_find(tcs
->parent
.parent
.t_a
, LTTV_STATS_USE_COUNT
,
104 if(*(v
.v_uint
) == 1) {
105 g_assert(lttv_attribute_get_number(tcs
->stats
) == 0);
108 nb_tracefile
= tc
->tracefiles
->len
;
110 for(j
= 0 ; j
< nb_tracefile
; j
++) {
111 tfs
= &g_array_index(tc
->tracefiles
,
112 LttvTracefileContext
*, j
);
113 tfcs
= LTTV_TRACEFILE_STATS(*tfs
);
114 tfcs
->stats
= lttv_attribute_find_subdir(tracefiles_stats
,
115 ltt_tracefile_long_name(tfcs
->parent
.parent
.tf
));
116 guint cpu
= tfcs
->parent
.cpu
;
117 find_event_tree(tfcs
, LTTV_STATS_PROCESS_UNKNOWN
,
120 LTTV_STATE_MODE_UNKNOWN
,
121 LTTV_STATE_SUBMODE_UNKNOWN
, &tfcs
->current_events_tree
,
122 &tfcs
->current_event_types_tree
);
128 static void lttv_stats_fini(LttvTracesetStats
*self
)
130 guint i
, j
, nb_trace
, nb_tracefile
;
134 LttvTraceContext
*tc
;
138 LttvTracefileContext
*tfc
;
140 LttvTracefileStats
*tfcs
;
142 LttvAttributeValue v
;
144 LttvAttribute
*tracefiles_stats
;
146 lttv_attribute_find(self
->parent
.parent
.ts_a
, LTTV_STATS_USE_COUNT
,
150 if(*(v
.v_uint
) == 0) {
151 lttv_attribute_remove_by_name(self
->parent
.parent
.ts_a
, LTTV_STATS
);
155 ts
= self
->parent
.parent
.ts
;
156 nb_trace
= lttv_traceset_number(ts
);
158 for(i
= 0 ; i
< nb_trace
; i
++) {
159 tcs
= (LttvTraceStats
*)(tc
= (LTTV_TRACESET_CONTEXT(self
)->traces
[i
]));
161 lttv_attribute_find(tcs
->parent
.parent
.t_a
, LTTV_STATS_USE_COUNT
,
165 if(*(v
.v_uint
) == 0) {
166 lttv_attribute_remove_by_name(tcs
->parent
.parent
.t_a
,LTTV_STATS
);
167 tracefiles_stats
= lttv_attribute_find_subdir(tcs
->parent
.parent
.t_a
,
168 LTTV_STATS_TRACEFILES
);
169 lttv_attribute_remove_by_name(tcs
->parent
.parent
.t_a
,
170 LTTV_STATS_TRACEFILES
);
174 nb_tracefile
= tc
->tracefiles
->len
;
176 for(j
= 0 ; j
< nb_tracefile
; j
++) {
177 tfc
= g_array_index(tc
->tracefiles
,
178 LttvTracefileContext
*, j
);
179 tfcs
= (LttvTracefileStats
*)tfc
;
181 tfcs
->current_events_tree
= NULL
;
182 tfcs
->current_event_types_tree
= NULL
;
188 void lttv_stats_reset(LttvTracesetStats
*self
)
190 lttv_stats_fini(self
);
191 lttv_stats_init(self
);
197 init(LttvTracesetStats
*self
, LttvTraceset
*ts
)
199 LTTV_TRACESET_CONTEXT_CLASS(g_type_class_peek(LTTV_TRACESET_STATE_TYPE
))->
200 init((LttvTracesetContext
*)self
, ts
);
202 lttv_stats_init(self
);
207 fini(LttvTracesetStats
*self
)
209 lttv_stats_fini(self
);
211 LTTV_TRACESET_CONTEXT_CLASS(g_type_class_peek(LTTV_TRACESET_STATE_TYPE
))->
212 fini((LttvTracesetContext
*)self
);
216 static LttvTracesetContext
*
217 new_traceset_context(LttvTracesetContext
*self
)
219 return LTTV_TRACESET_CONTEXT(g_object_new(LTTV_TRACESET_STATS_TYPE
, NULL
));
223 static LttvTraceContext
*
224 new_trace_context(LttvTracesetContext
*self
)
226 return LTTV_TRACE_CONTEXT(g_object_new(LTTV_TRACE_STATS_TYPE
, NULL
));
230 static LttvTracefileContext
*
231 new_tracefile_context(LttvTracesetContext
*self
)
233 return LTTV_TRACEFILE_CONTEXT(g_object_new(LTTV_TRACEFILE_STATS_TYPE
, NULL
));
238 traceset_stats_instance_init (GTypeInstance
*instance
, gpointer g_class
)
244 traceset_stats_finalize (LttvTracesetStats
*self
)
246 G_OBJECT_CLASS(g_type_class_peek(LTTV_TRACESET_STATE_TYPE
))->
247 finalize(G_OBJECT(self
));
252 traceset_stats_class_init (LttvTracesetContextClass
*klass
)
254 GObjectClass
*gobject_class
= G_OBJECT_CLASS(klass
);
256 gobject_class
->finalize
= (void (*)(GObject
*self
)) traceset_stats_finalize
;
257 klass
->init
= (void (*)(LttvTracesetContext
*self
, LttvTraceset
*ts
))init
;
258 klass
->fini
= (void (*)(LttvTracesetContext
*self
))fini
;
259 klass
->new_traceset_context
= new_traceset_context
;
260 klass
->new_trace_context
= new_trace_context
;
261 klass
->new_tracefile_context
= new_tracefile_context
;
266 lttv_traceset_stats_get_type(void)
268 static GType type
= 0;
270 static const GTypeInfo info
= {
271 sizeof (LttvTracesetStatsClass
),
272 NULL
, /* base_init */
273 NULL
, /* base_finalize */
274 (GClassInitFunc
) traceset_stats_class_init
, /* class_init */
275 NULL
, /* class_finalize */
276 NULL
, /* class_data */
277 sizeof (LttvTracesetStats
),
279 (GInstanceInitFunc
) traceset_stats_instance_init
, /* instance_init */
280 NULL
/* Value handling */
283 type
= g_type_register_static (LTTV_TRACESET_STATE_TYPE
,
284 "LttvTracesetStatsType",
292 trace_stats_instance_init (GTypeInstance
*instance
, gpointer g_class
)
298 trace_stats_finalize (LttvTraceStats
*self
)
300 G_OBJECT_CLASS(g_type_class_peek(LTTV_TRACE_STATE_TYPE
))->
301 finalize(G_OBJECT(self
));
306 trace_stats_class_init (LttvTraceContextClass
*klass
)
308 GObjectClass
*gobject_class
= G_OBJECT_CLASS(klass
);
310 gobject_class
->finalize
= (void (*)(GObject
*self
)) trace_stats_finalize
;
315 lttv_trace_stats_get_type(void)
317 static GType type
= 0;
319 static const GTypeInfo info
= {
320 sizeof (LttvTraceStatsClass
),
321 NULL
, /* base_init */
322 NULL
, /* base_finalize */
323 (GClassInitFunc
) trace_stats_class_init
, /* class_init */
324 NULL
, /* class_finalize */
325 NULL
, /* class_data */
326 sizeof (LttvTraceStats
),
328 (GInstanceInitFunc
) trace_stats_instance_init
, /* instance_init */
329 NULL
/* Value handling */
332 type
= g_type_register_static (LTTV_TRACE_STATE_TYPE
,
333 "LttvTraceStatsType", &info
, 0);
340 tracefile_stats_instance_init (GTypeInstance
*instance
, gpointer g_class
)
346 tracefile_stats_finalize (LttvTracefileStats
*self
)
348 G_OBJECT_CLASS(g_type_class_peek(LTTV_TRACEFILE_STATE_TYPE
))->
349 finalize(G_OBJECT(self
));
354 tracefile_stats_class_init (LttvTracefileStatsClass
*klass
)
356 GObjectClass
*gobject_class
= G_OBJECT_CLASS(klass
);
358 gobject_class
->finalize
= (void (*)(GObject
*self
)) tracefile_stats_finalize
;
363 lttv_tracefile_stats_get_type(void)
365 static GType type
= 0;
367 static const GTypeInfo info
= {
368 sizeof (LttvTracefileStatsClass
),
369 NULL
, /* base_init */
370 NULL
, /* base_finalize */
371 (GClassInitFunc
) tracefile_stats_class_init
, /* class_init */
372 NULL
, /* class_finalize */
373 NULL
, /* class_data */
374 sizeof (LttvTracefileStats
),
376 (GInstanceInitFunc
) tracefile_stats_instance_init
, /* instance_init */
377 NULL
/* Value handling */
380 type
= g_type_register_static (LTTV_TRACEFILE_STATE_TYPE
,
381 "LttvTracefileStatsType", &info
, 0);
387 find_event_tree(LttvTracefileStats
*tfcs
,
393 LttvAttribute
**events_tree
,
394 LttvAttribute
**event_types_tree
)
397 gchar fstring
[MAX_64_HEX_STRING_LEN
];
400 ret
= snprintf(fstring
, MAX_64_HEX_STRING_LEN
-1,
401 "0x%llX", function
) > 0;
403 fstring
[MAX_64_HEX_STRING_LEN
-1] = '\0';
405 LttvTraceStats
*tcs
= (LttvTraceStats
*)tfcs
->parent
.parent
.t_context
;
406 a
= lttv_attribute_find_subdir(tcs
->stats
, LTTV_STATS_PROCESSES
);
407 a
= lttv_attribute_find_subdir(a
, pid_time
);
408 a
= lttv_attribute_find_subdir(a
, LTTV_STATS_CPU
);
409 a
= lttv_attribute_find_subdir_unnamed(a
, cpu
);
410 a
= lttv_attribute_find_subdir(a
, LTTV_STATS_FUNCTIONS
);
411 a
= lttv_attribute_find_subdir(a
, g_quark_from_string(fstring
));
412 a
= lttv_attribute_find_subdir(a
, LTTV_STATS_MODE_TYPES
);
413 a
= lttv_attribute_find_subdir(a
, mode
);
414 a
= lttv_attribute_find_subdir(a
, LTTV_STATS_SUBMODES
);
415 a
= lttv_attribute_find_subdir(a
, sub_mode
);
417 a
= lttv_attribute_find_subdir(a
, LTTV_STATS_EVENT_TYPES
);
418 *event_types_tree
= a
;
421 static void update_event_tree(LttvTracefileStats
*tfcs
)
423 guint cpu
= tfcs
->parent
.cpu
;
424 LttvTraceState
*ts
= (LttvTraceState
*)tfcs
->parent
.parent
.t_context
;
425 LttvProcessState
*process
= ts
->running_process
[cpu
];
426 LttvExecutionState
*es
= process
->state
;
428 find_event_tree(tfcs
, process
->pid_time
,
430 process
->current_function
,
431 es
->t
, es
->n
, &(tfcs
->current_events_tree
),
432 &(tfcs
->current_event_types_tree
));
436 /* Update the trace event tree for the specified cpu */
437 static void update_trace_event_tree(LttvTraceStats
*tcs
)
439 LttvTracefileStats
*tfcs
;
440 LttvTraceContext
*tc
= (LttvTraceContext
*)tcs
;
441 guint j
, nb_tracefile
;
443 /* For each tracefile, update the event tree */
444 nb_tracefile
= tc
->tracefiles
->len
;
445 for(j
= 0; j
< nb_tracefile
; j
++) {
446 tfcs
= LTTV_TRACEFILE_STATS(g_array_index(tc
->tracefiles
,
447 LttvTracefileContext
*, j
));
448 update_event_tree(tfcs
);
452 static void mode_change(LttvTracefileStats
*tfcs
)
454 LttvTraceState
*ts
= (LttvTraceState
*)tfcs
->parent
.parent
.t_context
;
455 guint cpu
= tfcs
->parent
.cpu
;
456 LttvProcessState
*process
= ts
->running_process
[cpu
];
457 LttvAttributeValue cpu_time
;
461 if(process
->state
->s
== LTTV_STATE_RUN
&&
462 process
->state
->t
!= LTTV_STATE_MODE_UNKNOWN
)
463 delta
= ltt_time_sub(tfcs
->parent
.parent
.timestamp
,
464 process
->state
->change
);
466 delta
= ltt_time_zero
;
468 lttv_attribute_find(tfcs
->current_events_tree
, LTTV_STATS_CPU_TIME
,
469 LTTV_TIME
, &cpu_time
);
470 *(cpu_time
.v_time
) = ltt_time_add(*(cpu_time
.v_time
), delta
);
472 process
->state
->cum_cpu_time
= ltt_time_add(process
->state
->cum_cpu_time
,
476 /* Note : every mode_end must come with a cumulative cpu time update in the
478 static void mode_end(LttvTracefileStats
*tfcs
)
480 LttvTraceState
*ts
= (LttvTraceState
*)tfcs
->parent
.parent
.t_context
;
481 guint cpu
= tfcs
->parent
.cpu
;
482 LttvProcessState
*process
= ts
->running_process
[cpu
];
483 LttvAttributeValue elapsed_time
, cpu_time
, cum_cpu_time
;
487 /* FIXME put there in case of a missing update after a state modification */
488 //void *lasttree = tfcs->current_events_tree;
489 //update_event_tree(tfcs);
490 //g_assert (lasttree == tfcs->current_events_tree);
491 lttv_attribute_find(tfcs
->current_events_tree
, LTTV_STATS_ELAPSED_TIME
,
492 LTTV_TIME
, &elapsed_time
);
494 if(process
->state
->t
!= LTTV_STATE_MODE_UNKNOWN
) {
495 delta
= ltt_time_sub(tfcs
->parent
.parent
.timestamp
,
496 process
->state
->entry
);
498 delta
= ltt_time_zero
;
500 *(elapsed_time
.v_time
) = ltt_time_add(*(elapsed_time
.v_time
), delta
);
502 lttv_attribute_find(tfcs
->current_events_tree
, LTTV_STATS_CPU_TIME
,
503 LTTV_TIME
, &cpu_time
);
505 /* if it is a running mode, we must count its cpu time */
506 if(process
->state
->s
== LTTV_STATE_RUN
&&
507 process
->state
->t
!= LTTV_STATE_MODE_UNKNOWN
)
508 delta
= ltt_time_sub(tfcs
->parent
.parent
.timestamp
,
509 process
->state
->change
);
511 delta
= ltt_time_zero
;
513 *(cpu_time
.v_time
) = ltt_time_add(*(cpu_time
.v_time
), delta
);
514 process
->state
->cum_cpu_time
= ltt_time_add(process
->state
->cum_cpu_time
,
517 lttv_attribute_find(tfcs
->current_events_tree
, LTTV_STATS_CUMULATIVE_CPU_TIME
,
518 LTTV_TIME
, &cum_cpu_time
);
519 *(cum_cpu_time
.v_time
) = ltt_time_add(*(cum_cpu_time
.v_time
),
520 process
->state
->cum_cpu_time
);
524 static void after_mode_end(LttvTracefileStats
*tfcs
)
526 LttvTraceState
*ts
= (LttvTraceState
*)tfcs
->parent
.parent
.t_context
;
527 guint cpu
= tfcs
->parent
.cpu
;
528 LttvProcessState
*process
= ts
->running_process
[cpu
];
530 LttTime nested_delta
;
532 nested_delta
= process
->state
->cum_cpu_time
;
533 process
->state
->cum_cpu_time
= ltt_time_zero
; /* For after traceset hook */
535 update_event_tree(tfcs
);
537 process
->state
->cum_cpu_time
= ltt_time_add(process
->state
->cum_cpu_time
,
541 static gboolean
before_syscall_entry(void *hook_data
, void *call_data
)
543 mode_change((LttvTracefileStats
*)call_data
);
548 static gboolean
after_syscall_entry(void *hook_data
, void *call_data
)
550 update_event_tree((LttvTracefileStats
*)call_data
);
555 static gboolean
before_syscall_exit(void *hook_data
, void *call_data
)
557 mode_end((LttvTracefileStats
*)call_data
);
562 static gboolean
after_syscall_exit(void *hook_data
, void *call_data
)
564 after_mode_end((LttvTracefileStats
*)call_data
);
569 static gboolean
before_trap_entry(void *hook_data
, void *call_data
)
571 mode_change((LttvTracefileStats
*)call_data
);
576 static gboolean
after_trap_entry(void *hook_data
, void *call_data
)
578 update_event_tree((LttvTracefileStats
*)call_data
);
583 static gboolean
before_trap_exit(void *hook_data
, void *call_data
)
585 mode_end((LttvTracefileStats
*)call_data
);
590 static gboolean
after_trap_exit(void *hook_data
, void *call_data
)
592 after_mode_end((LttvTracefileStats
*)call_data
);
597 static gboolean
before_irq_entry(void *hook_data
, void *call_data
)
599 mode_change((LttvTracefileStats
*)call_data
);
603 static gboolean
after_irq_entry(void *hook_data
, void *call_data
)
605 update_event_tree((LttvTracefileStats
*)call_data
);
610 static gboolean
before_irq_exit(void *hook_data
, void *call_data
)
612 mode_end((LttvTracefileStats
*)call_data
);
617 static gboolean
after_irq_exit(void *hook_data
, void *call_data
)
619 after_mode_end((LttvTracefileStats
*)call_data
);
624 static gboolean
before_soft_irq_entry(void *hook_data
, void *call_data
)
626 mode_change((LttvTracefileStats
*)call_data
);
630 static gboolean
after_soft_irq_entry(void *hook_data
, void *call_data
)
632 update_event_tree((LttvTracefileStats
*)call_data
);
636 static gboolean
before_soft_irq_exit(void *hook_data
, void *call_data
)
638 mode_end((LttvTracefileStats
*)call_data
);
643 static gboolean
after_soft_irq_exit(void *hook_data
, void *call_data
)
645 after_mode_end((LttvTracefileStats
*)call_data
);
649 static gboolean
before_function_entry(void *hook_data
, void *call_data
)
651 mode_change((LttvTracefileStats
*)call_data
);
655 static gboolean
after_function_entry(void *hook_data
, void *call_data
)
657 update_event_tree((LttvTracefileStats
*)call_data
);
661 static gboolean
before_function_exit(void *hook_data
, void *call_data
)
663 mode_end((LttvTracefileStats
*)call_data
);
667 static gboolean
after_function_exit(void *hook_data
, void *call_data
)
669 after_mode_end((LttvTracefileStats
*)call_data
);
674 static gboolean
before_schedchange(void *hook_data
, void *call_data
)
676 LttvTracefileStats
*tfcs
= (LttvTracefileStats
*)call_data
;
678 LttEvent
*e
= ltt_tracefile_get_event(tfcs
->parent
.parent
.tf
);
680 LttvTraceHook
*th
= (LttvTraceHook
*)hook_data
;
682 guint pid_in
, pid_out
;
686 pid_out
= ltt_event_get_unsigned(e
, lttv_trace_get_hook_field(th
, 0));
687 pid_in
= ltt_event_get_unsigned(e
, lttv_trace_get_hook_field(th
, 1));
688 state_out
= ltt_event_get_long_int(e
, lttv_trace_get_hook_field(th
, 2));
690 /* compute the time for the process to schedule out */
696 static gboolean
after_schedchange(void *hook_data
, void *call_data
)
698 LttvTracefileStats
*tfcs
= (LttvTracefileStats
*)call_data
;
700 LttvTraceState
*ts
= (LttvTraceState
*)tfcs
->parent
.parent
.t_context
;
702 LttEvent
*e
= ltt_tracefile_get_event(tfcs
->parent
.parent
.tf
);
704 LttvTraceHook
*th
= (LttvTraceHook
*)hook_data
;
706 guint pid_in
, pid_out
;
710 LttvProcessState
*process
;
712 pid_out
= ltt_event_get_unsigned(e
, lttv_trace_get_hook_field(th
, 0));
713 pid_in
= ltt_event_get_unsigned(e
, lttv_trace_get_hook_field(th
, 1));
714 state_out
= ltt_event_get_long_int(e
, lttv_trace_get_hook_field(th
, 2));
716 /* get the information for the process scheduled in */
717 guint cpu
= tfcs
->parent
.cpu
;
718 process
= ts
->running_process
[cpu
];
720 find_event_tree(tfcs
, process
->pid_time
,
722 process
->current_function
,
723 process
->state
->t
, process
->state
->n
, &(tfcs
->current_events_tree
),
724 &(tfcs
->current_event_types_tree
));
726 /* compute the time waiting for the process to schedule in */
732 static gboolean
process_fork(void *hook_data
, void *call_data
)
737 static gboolean
process_exit(void *hook_data
, void *call_data
)
739 update_event_tree((LttvTracefileStats
*)call_data
);
743 static gboolean
before_enum_process_state(void *hook_data
, void *call_data
)
746 /* Broken : adds up time in the current process doing the dump */
747 LttvTracefileStats
*tfcs
= (LttvTracefileStats
*)call_data
;
749 after_mode_end(tfcs
);
755 static gboolean
after_enum_process_state(void *hook_data
, void *call_data
)
757 LttvTracefileContext
*tfc
= (LttvTracefileContext
*)call_data
;
758 LttvTraceStats
*tcs
= (LttvTraceStats
*)tfc
->t_context
;
759 update_trace_event_tree(tcs
);
763 static gboolean
after_statedump_end(void *hook_data
, void *call_data
)
765 LttvTracefileContext
*tfc
= (LttvTracefileContext
*)call_data
;
766 LttvTraceStats
*tcs
= (LttvTraceStats
*)tfc
->t_context
;
767 update_trace_event_tree(tcs
);
771 static gboolean
process_free(void *hook_data
, void *call_data
)
776 static gboolean
every_event(void *hook_data
, void *call_data
)
778 LttvTracefileStats
*tfcs
= (LttvTracefileStats
*)call_data
;
780 LttEvent
*e
= ltt_tracefile_get_event(tfcs
->parent
.parent
.tf
);
782 LttvAttributeValue v
;
784 LttTrace
*trace
= ((LttvTracefileContext
*)tfcs
)->t_context
->t
;
786 struct marker_info
*info
;
788 /* The current branch corresponds to the tracefile/process/interrupt state.
789 Statistics are added within it, to count the number of events of this
790 type occuring in this context. A quark has been pre-allocated for each
791 event type and is used as name. */
793 info
= marker_get_info_from_id(trace
, e
->event_id
);
795 lttv_attribute_find(tfcs
->current_event_types_tree
,
796 info
->name
, LTTV_UINT
, &v
);
801 struct cleanup_state_struct
{
803 LttTime current_time
;
806 //static void lttv_stats_cleanup_process_state(LttvTraceState *ts,
807 // LttvProcessState *process, LttTime current_time)
808 static void lttv_stats_cleanup_process_state(gpointer key
, gpointer value
,
811 struct cleanup_state_struct
*cleanup_closure
=
812 (struct cleanup_state_struct
*)user_data
;
813 LttvTraceState
*ts
= cleanup_closure
->ts
;
814 LttvProcessState
*process
= (LttvProcessState
*)value
;
815 LttTime current_time
= cleanup_closure
->current_time
;
816 LttvTracefileStats
**tfs
= (LttvTracefileStats
**)
817 &g_array_index(ts
->parent
.tracefiles
, LttvTracefileContext
*,
819 int cleanup_empty
= 0;
820 LttTime nested_delta
= ltt_time_zero
;
822 /* FIXME : ok, this is a hack. The time is infinite here :( */
823 //LttTime save_time = (*tfs)->parent.parent.timestamp;
824 //LttTime start, end;
825 //ltt_trace_time_span_get(ts->parent.t, &start, &end);
826 //(*tfs)->parent.parent.timestamp = end;
829 if(ltt_time_compare(process
->state
->cum_cpu_time
, ltt_time_zero
) != 0) {
830 find_event_tree(*tfs
, process
->pid_time
,
832 process
->current_function
,
833 process
->state
->t
, process
->state
->n
, &((*tfs
)->current_events_tree
),
834 &((*tfs
)->current_event_types_tree
));
835 /* Call mode_end only if not at end of trace */
836 if(ltt_time_compare(current_time
, ltt_time_infinite
) != 0)
838 nested_delta
= process
->state
->cum_cpu_time
;
840 cleanup_empty
= lttv_state_pop_state_cleanup(process
,
841 (LttvTracefileState
*)*tfs
);
842 process
->state
->cum_cpu_time
= ltt_time_add(process
->state
->cum_cpu_time
,
845 } while(cleanup_empty
!= 1);
847 //(*tfs)->parent.parent.timestamp = save_time;
850 /* For each cpu, for each of their stacked states,
851 * perform sum of needed values. */
852 static void lttv_stats_cleanup_state(LttvTraceStats
*tcs
, LttTime current_time
)
854 LttvTraceState
*ts
= (LttvTraceState
*)tcs
;
855 struct cleanup_state_struct cleanup_closure
;
859 nb_cpus
= ltt_trace_get_num_cpu(ts
->parent
.t
);
861 for(i
=0; i
<nb_cpus
; i
++) {
862 lttv_stats_cleanup_process_state(ts
, ts
->running_process
[i
], current_time
);
865 cleanup_closure
.ts
= ts
;
866 cleanup_closure
.current_time
= current_time
;
867 g_hash_table_foreach(ts
->processes
, lttv_stats_cleanup_process_state
,
872 lttv_stats_sum_trace(LttvTraceStats
*self
, LttvAttribute
*ts_stats
,
873 LttTime current_time
)
875 LttvAttribute
*sum_container
= self
->stats
;
877 LttvAttributeType type
;
879 LttvAttributeValue value
;
881 LttvAttributeName name
;
889 int i
, j
, k
, l
, m
, nb_process
, nb_cpu
, nb_mode_type
, nb_submode
,
890 nb_event_type
, nf
, nb_functions
;
892 LttvAttribute
*main_tree
, *processes_tree
, *process_tree
, *cpus_tree
,
893 *cpu_tree
, *mode_tree
, *mode_types_tree
, *submodes_tree
,
894 *submode_tree
, *event_types_tree
, *mode_events_tree
,
897 *function_mode_types_tree
,
901 main_tree
= sum_container
;
903 lttv_attribute_find(sum_container
,
906 trace_is_summed
= *(value
.v_uint
);
909 /* First cleanup the state : sum all stalled information (never ending
912 lttv_stats_cleanup_state(self
, current_time
);
914 processes_tree
= lttv_attribute_find_subdir(main_tree
,
915 LTTV_STATS_PROCESSES
);
916 nb_process
= lttv_attribute_get_number(processes_tree
);
918 for(i
= 0 ; i
< nb_process
; i
++) {
919 type
= lttv_attribute_get(processes_tree
, i
, &name
, &value
, &is_named
);
920 process_tree
= LTTV_ATTRIBUTE(*(value
.v_gobject
));
922 cpus_tree
= lttv_attribute_find_subdir(process_tree
, LTTV_STATS_CPU
);
923 nb_cpu
= lttv_attribute_get_number(cpus_tree
);
925 for(j
= 0 ; j
< nb_cpu
; j
++) {
926 type
= lttv_attribute_get(cpus_tree
, j
, &name
, &value
, &is_named
);
927 cpu_tree
= LTTV_ATTRIBUTE(*(value
.v_gobject
));
929 trace_cpu_tree
= lttv_attribute_find_subdir(main_tree
, LTTV_STATS_CPU
);
930 trace_cpu_tree
= lttv_attribute_find_subdir_unnamed(trace_cpu_tree
, name
);
931 cpu_functions_tree
= lttv_attribute_find_subdir(cpu_tree
,
932 LTTV_STATS_FUNCTIONS
);
933 nb_functions
= lttv_attribute_get_number(cpu_functions_tree
);
935 for(nf
=0; nf
< nb_functions
; nf
++) {
936 type
= lttv_attribute_get(cpu_functions_tree
, nf
, &name
, &value
,
938 function_tree
= LTTV_ATTRIBUTE(*(value
.v_gobject
));
939 function_mode_types_tree
= lttv_attribute_find_subdir(function_tree
,
940 LTTV_STATS_MODE_TYPES
);
941 nb_mode_type
= lttv_attribute_get_number(function_mode_types_tree
);
942 for(k
= 0 ; k
< nb_mode_type
; k
++) {
943 type
= lttv_attribute_get(function_mode_types_tree
, k
, &name
, &value
,
945 mode_tree
= LTTV_ATTRIBUTE(*(value
.v_gobject
));
947 submodes_tree
= lttv_attribute_find_subdir(mode_tree
,
948 LTTV_STATS_SUBMODES
);
949 mode_events_tree
= lttv_attribute_find_subdir(mode_tree
,
951 mode_types_tree
= lttv_attribute_find_subdir(mode_tree
,
952 LTTV_STATS_MODE_TYPES
);
954 nb_submode
= lttv_attribute_get_number(submodes_tree
);
956 for(l
= 0 ; l
< nb_submode
; l
++) {
957 type
= lttv_attribute_get(submodes_tree
, l
, &name
, &value
,
959 submode_tree
= LTTV_ATTRIBUTE(*(value
.v_gobject
));
961 event_types_tree
= lttv_attribute_find_subdir(submode_tree
,
962 LTTV_STATS_EVENT_TYPES
);
963 nb_event_type
= lttv_attribute_get_number(event_types_tree
);
966 for(m
= 0 ; m
< nb_event_type
; m
++) {
967 type
= lttv_attribute_get(event_types_tree
, m
, &name
, &value
,
969 sum
+= *(value
.v_uint
);
971 lttv_attribute_find(submode_tree
, LTTV_STATS_EVENTS_COUNT
,
973 *(value
.v_uint
) = sum
;
975 type
= lttv_attribute_get(submodes_tree
, l
, &name
, &value
,
977 submode_tree
= LTTV_ATTRIBUTE(*(value
.v_gobject
));
978 if(!trace_is_summed
) {
979 lttv_attribute_recursive_add(mode_events_tree
, event_types_tree
);
980 lttv_attribute_recursive_add(mode_types_tree
, submode_tree
);
983 if(!trace_is_summed
) {
984 lttv_attribute_recursive_add(function_tree
, mode_types_tree
);
987 if(!trace_is_summed
) {
988 lttv_attribute_recursive_add(cpu_tree
, function_tree
);
989 lttv_attribute_recursive_add(process_tree
, function_tree
);
990 lttv_attribute_recursive_add(trace_cpu_tree
, function_tree
);
991 lttv_attribute_recursive_add(main_tree
, function_tree
);
993 lttv_attribute_recursive_add(ts_stats
, function_tree
);
1000 gboolean
lttv_stats_sum_traceset_hook(void *hook_data
, void *call_data
)
1002 struct sum_traceset_closure
*closure
=
1003 (struct sum_traceset_closure
*)call_data
;
1004 lttv_stats_sum_traceset(closure
->tss
, closure
->current_time
);
1009 lttv_stats_sum_traceset(LttvTracesetStats
*self
, LttTime current_time
)
1011 LttvTraceset
*traceset
= self
->parent
.parent
.ts
;
1012 LttvAttribute
*sum_container
= self
->stats
;
1014 LttvTraceStats
*tcs
;
1018 LttvAttributeValue value
;
1020 lttv_attribute_find(sum_container
, LTTV_STATS_SUMMED
,
1022 if(*(value
.v_uint
) != 0) return;
1023 *(value
.v_uint
) = 1;
1025 nb_trace
= lttv_traceset_number(traceset
);
1027 for(i
= 0 ; i
< nb_trace
; i
++) {
1028 tcs
= (LttvTraceStats
*)(self
->parent
.parent
.traces
[i
]);
1029 lttv_stats_sum_trace(tcs
, self
->stats
, current_time
);
1030 // lttv_attribute_recursive_add(sum_container, tcs->stats);
1035 // Hook wrapper. call_data is a traceset context.
1036 gboolean
lttv_stats_hook_add_event_hooks(void *hook_data
, void *call_data
)
1038 LttvTracesetStats
*tss
= (LttvTracesetStats
*)call_data
;
1040 lttv_stats_add_event_hooks(tss
);
1045 void lttv_stats_add_event_hooks(LttvTracesetStats
*self
)
1047 LttvTraceset
*traceset
= self
->parent
.parent
.ts
;
1049 guint i
, j
, k
, nb_trace
, nb_tracefile
;
1053 LttvTracefileStats
*tfs
;
1055 GArray
*hooks
, *before_hooks
, *after_hooks
;
1059 LttvAttributeValue val
;
1061 nb_trace
= lttv_traceset_number(traceset
);
1062 for(i
= 0 ; i
< nb_trace
; i
++) {
1063 ts
= (LttvTraceStats
*)self
->parent
.parent
.traces
[i
];
1065 /* Find the eventtype id for the following events and register the
1066 associated by id hooks. */
1068 hooks
= g_array_sized_new(FALSE
, FALSE
, sizeof(LttvTraceHook
), 12);
1070 lttv_trace_find_hook(ts
->parent
.parent
.t
,
1071 LTT_FACILITY_KERNEL_ARCH
,
1072 LTT_EVENT_SYSCALL_ENTRY
,
1073 FIELD_ARRAY(LTT_FIELD_SYSCALL_ID
),
1074 before_syscall_entry
, NULL
,
1077 lttv_trace_find_hook(ts
->parent
.parent
.t
,
1078 LTT_FACILITY_KERNEL_ARCH
,
1079 LTT_EVENT_SYSCALL_EXIT
,
1081 before_syscall_exit
, NULL
,
1084 lttv_trace_find_hook(ts
->parent
.parent
.t
,
1085 LTT_FACILITY_KERNEL_ARCH
,
1086 LTT_EVENT_TRAP_ENTRY
,
1087 FIELD_ARRAY(LTT_FIELD_TRAP_ID
),
1088 before_trap_entry
, NULL
,
1091 lttv_trace_find_hook(ts
->parent
.parent
.t
,
1092 LTT_FACILITY_KERNEL_ARCH
,
1093 LTT_EVENT_TRAP_EXIT
,
1095 before_trap_exit
, NULL
,
1098 lttv_trace_find_hook(ts
->parent
.parent
.t
,
1099 LTT_FACILITY_KERNEL
,
1100 LTT_EVENT_IRQ_ENTRY
,
1101 FIELD_ARRAY(LTT_FIELD_IRQ_ID
),
1102 before_irq_entry
, NULL
,
1105 lttv_trace_find_hook(ts
->parent
.parent
.t
,
1106 LTT_FACILITY_KERNEL
,
1109 before_irq_exit
, NULL
,
1112 lttv_trace_find_hook(ts
->parent
.parent
.t
,
1113 LTT_FACILITY_KERNEL
,
1114 LTT_EVENT_SOFT_IRQ_ENTRY
,
1115 FIELD_ARRAY(LTT_FIELD_SOFT_IRQ_ID
),
1116 before_soft_irq_entry
, NULL
,
1119 lttv_trace_find_hook(ts
->parent
.parent
.t
,
1120 LTT_FACILITY_KERNEL
,
1121 LTT_EVENT_SOFT_IRQ_EXIT
,
1123 before_soft_irq_exit
, NULL
,
1126 lttv_trace_find_hook(ts
->parent
.parent
.t
,
1127 LTT_FACILITY_KERNEL
,
1128 LTT_EVENT_SCHED_SCHEDULE
,
1129 FIELD_ARRAY(LTT_FIELD_PREV_PID
, LTT_FIELD_NEXT_PID
, LTT_FIELD_PREV_STATE
),
1130 before_schedchange
, NULL
,
1133 lttv_trace_find_hook(ts
->parent
.parent
.t
,
1134 LTT_FACILITY_USER_GENERIC
,
1135 LTT_EVENT_FUNCTION_ENTRY
,
1136 FIELD_ARRAY(LTT_FIELD_THIS_FN
, LTT_FIELD_CALL_SITE
),
1137 before_function_entry
, NULL
,
1140 lttv_trace_find_hook(ts
->parent
.parent
.t
,
1141 LTT_FACILITY_USER_GENERIC
,
1142 LTT_EVENT_FUNCTION_EXIT
,
1143 FIELD_ARRAY(LTT_FIELD_THIS_FN
, LTT_FIELD_CALL_SITE
),
1144 before_function_exit
, NULL
,
1147 /* statedump-related hooks */
1148 lttv_trace_find_hook(ts
->parent
.parent
.t
,
1150 LTT_EVENT_PROCESS_STATE
,
1151 FIELD_ARRAY(LTT_FIELD_PID
, LTT_FIELD_PARENT_PID
, LTT_FIELD_NAME
),
1152 before_enum_process_state
, NULL
,
1155 before_hooks
= hooks
;
1157 hooks
= g_array_sized_new(FALSE
, FALSE
, sizeof(LttvTraceHook
), 16);
1159 lttv_trace_find_hook(ts
->parent
.parent
.t
,
1160 LTT_FACILITY_KERNEL_ARCH
,
1161 LTT_EVENT_SYSCALL_ENTRY
,
1162 FIELD_ARRAY(LTT_FIELD_SYSCALL_ID
),
1163 after_syscall_entry
, NULL
,
1166 lttv_trace_find_hook(ts
->parent
.parent
.t
,
1167 LTT_FACILITY_KERNEL_ARCH
,
1168 LTT_EVENT_SYSCALL_EXIT
,
1170 after_syscall_exit
, NULL
,
1173 lttv_trace_find_hook(ts
->parent
.parent
.t
,
1174 LTT_FACILITY_KERNEL_ARCH
,
1175 LTT_EVENT_TRAP_ENTRY
,
1176 FIELD_ARRAY(LTT_FIELD_TRAP_ID
),
1177 after_trap_entry
, NULL
,
1180 lttv_trace_find_hook(ts
->parent
.parent
.t
,
1181 LTT_FACILITY_KERNEL_ARCH
,
1182 LTT_EVENT_TRAP_EXIT
,
1184 after_trap_exit
, NULL
,
1187 lttv_trace_find_hook(ts
->parent
.parent
.t
,
1188 LTT_FACILITY_KERNEL
,
1189 LTT_EVENT_IRQ_ENTRY
,
1190 FIELD_ARRAY(LTT_FIELD_IRQ_ID
),
1191 after_irq_entry
, NULL
,
1194 lttv_trace_find_hook(ts
->parent
.parent
.t
,
1195 LTT_FACILITY_KERNEL
,
1198 after_irq_exit
, NULL
,
1201 lttv_trace_find_hook(ts
->parent
.parent
.t
,
1202 LTT_FACILITY_KERNEL
,
1203 LTT_EVENT_SOFT_IRQ_ENTRY
,
1204 FIELD_ARRAY(LTT_FIELD_SOFT_IRQ_ID
),
1205 after_soft_irq_entry
, NULL
,
1208 lttv_trace_find_hook(ts
->parent
.parent
.t
,
1209 LTT_FACILITY_KERNEL
,
1210 LTT_EVENT_SOFT_IRQ_EXIT
,
1212 after_soft_irq_exit
, NULL
,
1215 lttv_trace_find_hook(ts
->parent
.parent
.t
,
1216 LTT_FACILITY_KERNEL
,
1217 LTT_EVENT_SCHED_SCHEDULE
,
1218 FIELD_ARRAY(LTT_FIELD_PREV_PID
, LTT_FIELD_NEXT_PID
, LTT_FIELD_PREV_STATE
),
1219 after_schedchange
, NULL
,
1222 lttv_trace_find_hook(ts
->parent
.parent
.t
,
1223 LTT_FACILITY_KERNEL
,
1224 LTT_EVENT_PROCESS_FORK
,
1225 FIELD_ARRAY(LTT_FIELD_PARENT_PID
, LTT_FIELD_CHILD_PID
),
1229 lttv_trace_find_hook(ts
->parent
.parent
.t
,
1230 LTT_FACILITY_KERNEL
,
1231 LTT_EVENT_PROCESS_EXIT
,
1232 FIELD_ARRAY(LTT_FIELD_PID
),
1236 lttv_trace_find_hook(ts
->parent
.parent
.t
,
1237 LTT_FACILITY_KERNEL
,
1238 LTT_EVENT_PROCESS_FREE
,
1239 FIELD_ARRAY(LTT_FIELD_PID
),
1243 lttv_trace_find_hook(ts
->parent
.parent
.t
,
1244 LTT_FACILITY_USER_GENERIC
,
1245 LTT_EVENT_FUNCTION_ENTRY
,
1246 FIELD_ARRAY(LTT_FIELD_THIS_FN
, LTT_FIELD_CALL_SITE
),
1247 after_function_entry
, NULL
,
1250 lttv_trace_find_hook(ts
->parent
.parent
.t
,
1251 LTT_FACILITY_USER_GENERIC
,
1252 LTT_EVENT_FUNCTION_EXIT
,
1253 FIELD_ARRAY(LTT_FIELD_THIS_FN
, LTT_FIELD_CALL_SITE
),
1254 after_function_exit
, NULL
,
1257 /* statedump-related hooks */
1258 lttv_trace_find_hook(ts
->parent
.parent
.t
,
1260 LTT_EVENT_PROCESS_STATE
,
1261 FIELD_ARRAY(LTT_FIELD_PID
, LTT_FIELD_PARENT_PID
, LTT_FIELD_NAME
),
1262 after_enum_process_state
, NULL
,
1265 lttv_trace_find_hook(ts
->parent
.parent
.t
,
1267 LTT_EVENT_STATEDUMP_END
,
1269 after_statedump_end
, NULL
,
1272 after_hooks
= hooks
;
1274 /* Add these hooks to each event_by_id hooks list */
1276 nb_tracefile
= ts
->parent
.parent
.tracefiles
->len
;
1278 for(j
= 0 ; j
< nb_tracefile
; j
++) {
1279 tfs
= LTTV_TRACEFILE_STATS(g_array_index(ts
->parent
.parent
.tracefiles
,
1280 LttvTracefileContext
*, j
));
1281 lttv_hooks_add(tfs
->parent
.parent
.event
, every_event
, NULL
,
1284 for(k
= 0 ; k
< before_hooks
->len
; k
++) {
1285 th
= &g_array_index(before_hooks
, LttvTraceHook
, k
);
1287 lttv_hooks_by_id_find(tfs
->parent
.parent
.event_by_id
, th
->id
),
1290 LTTV_PRIO_STATS_BEFORE_STATE
);
1292 for(k
= 0 ; k
< after_hooks
->len
; k
++) {
1293 th
= &g_array_index(after_hooks
, LttvTraceHook
, k
);
1295 lttv_hooks_by_id_find(tfs
->parent
.parent
.event_by_id
, th
->id
),
1298 LTTV_PRIO_STATS_AFTER_STATE
);
1301 lttv_attribute_find(self
->parent
.parent
.a
, LTTV_STATS_BEFORE_HOOKS
,
1302 LTTV_POINTER
, &val
);
1303 *(val
.v_pointer
) = before_hooks
;
1304 lttv_attribute_find(self
->parent
.parent
.a
, LTTV_STATS_AFTER_HOOKS
,
1305 LTTV_POINTER
, &val
);
1306 *(val
.v_pointer
) = after_hooks
;
1310 // Hook wrapper. call_data is a traceset context.
1311 gboolean
lttv_stats_hook_remove_event_hooks(void *hook_data
, void *call_data
)
1313 LttvTracesetStats
*tss
= (LttvTracesetStats
*)call_data
;
1315 lttv_stats_remove_event_hooks(tss
);
1320 void lttv_stats_remove_event_hooks(LttvTracesetStats
*self
)
1322 LttvTraceset
*traceset
= self
->parent
.parent
.ts
;
1324 guint i
, j
, k
, nb_trace
, nb_tracefile
;
1328 LttvTracefileStats
*tfs
;
1330 GArray
*before_hooks
, *after_hooks
;
1334 LttvAttributeValue val
;
1336 nb_trace
= lttv_traceset_number(traceset
);
1337 for(i
= 0 ; i
< nb_trace
; i
++) {
1338 ts
= (LttvTraceStats
*)self
->parent
.parent
.traces
[i
];
1339 lttv_attribute_find(self
->parent
.parent
.a
, LTTV_STATS_BEFORE_HOOKS
,
1340 LTTV_POINTER
, &val
);
1341 before_hooks
= *(val
.v_pointer
);
1342 lttv_attribute_find(self
->parent
.parent
.a
, LTTV_STATS_AFTER_HOOKS
,
1343 LTTV_POINTER
, &val
);
1344 after_hooks
= *(val
.v_pointer
);
1346 /* Remove these hooks from each event_by_id hooks list */
1348 nb_tracefile
= ts
->parent
.parent
.tracefiles
->len
;
1350 for(j
= 0 ; j
< nb_tracefile
; j
++) {
1351 tfs
= LTTV_TRACEFILE_STATS(g_array_index(ts
->parent
.parent
.tracefiles
,
1352 LttvTracefileContext
*, j
));
1353 lttv_hooks_remove_data(tfs
->parent
.parent
.event
, every_event
,
1356 for(k
= 0 ; k
< before_hooks
->len
; k
++) {
1357 th
= &g_array_index(before_hooks
, LttvTraceHook
, k
);
1358 lttv_hooks_remove_data(
1359 lttv_hooks_by_id_find(tfs
->parent
.parent
.event_by_id
, th
->id
),
1363 for(k
= 0 ; k
< after_hooks
->len
; k
++) {
1364 th
= &g_array_index(after_hooks
, LttvTraceHook
, k
);
1365 lttv_hooks_remove_data(
1366 lttv_hooks_by_id_find(tfs
->parent
.parent
.event_by_id
, th
->id
),
1372 g_debug("lttv_stats_remove_event_hooks()");
1373 lttv_trace_hook_remove_all(&before_hooks
);
1374 lttv_trace_hook_remove_all(&after_hooks
);
1375 g_array_free(before_hooks
, TRUE
);
1376 g_array_free(after_hooks
, TRUE
);
1381 static void module_init()
1383 LTTV_STATS_PROCESS_UNKNOWN
= g_quark_from_string("unknown process");
1384 LTTV_STATS_PROCESSES
= g_quark_from_string("processes");
1385 LTTV_STATS_CPU
= g_quark_from_string("cpu");
1386 LTTV_STATS_MODE_TYPES
= g_quark_from_string("mode_types");
1387 LTTV_STATS_MODES
= g_quark_from_string("modes");
1388 LTTV_STATS_SUBMODES
= g_quark_from_string("submodes");
1389 LTTV_STATS_FUNCTIONS
= g_quark_from_string("functions");
1390 LTTV_STATS_EVENT_TYPES
= g_quark_from_string("event_types");
1391 LTTV_STATS_CPU_TIME
= g_quark_from_string("cpu time");
1392 LTTV_STATS_CUMULATIVE_CPU_TIME
= g_quark_from_string("cumulative cpu time (includes nested routines and modes)");
1393 LTTV_STATS_ELAPSED_TIME
= g_quark_from_string("elapsed time (includes per process waiting time)");
1394 LTTV_STATS_EVENTS
= g_quark_from_string("events");
1395 LTTV_STATS_EVENTS_COUNT
= g_quark_from_string("events count");
1396 LTTV_STATS_BEFORE_HOOKS
= g_quark_from_string("saved stats before hooks");
1397 LTTV_STATS_AFTER_HOOKS
= g_quark_from_string("saved stats after hooks");
1398 LTTV_STATS_USE_COUNT
= g_quark_from_string("stats_use_count");
1399 LTTV_STATS
= g_quark_from_string("statistics");
1400 LTTV_STATS_TRACEFILES
= g_quark_from_string("tracefiles statistics");
1401 LTTV_STATS_SUMMED
= g_quark_from_string("statistics summed");
1404 static void module_destroy()
1409 LTTV_MODULE("stats", "Compute processes statistics", \
1410 "Accumulate statistics for event types, processes and CPUs", \
1411 module_init
, module_destroy
, "state");
1413 /* Change the places where stats are called (create/read/write stats)
1415 Check for options in batchtest.c to reduce writing and see what tests are
1416 best candidates for performance analysis. Once OK, commit, move to main
1417 and run tests. Update the gui for statistics. */