projects / lttv.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
Update FSF address
[lttv.git] / lttv / lttv / stats.c
1 /* This file is part of the Linux Trace Toolkit viewer
2 * Copyright (C) 2003-2004 Michel Dagenais
3 *
4 * This program is free software; you can redistribute it and/or modify
5 * it under the terms of the GNU General Public License Version 2 as
6 * published by the Free Software Foundation;
7 *
8 * This program is distributed in the hope that it will be useful,
9 * but WITHOUT ANY WARRANTY; without even the implied warranty of
10 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
11 * GNU General Public License for more details.
12 *
13 * You should have received a copy of the GNU General Public License
14 * along with this program; if not, write to the Free Software
15 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston,
16 * MA 02110-1301, USA.
17 */
18
19 #ifdef HAVE_CONFIG_H
20 #include <config.h>
21 #endif
22
23 #include <stdio.h>
24 #include <inttypes.h>
25 #include <lttv/module.h>
26 #include <lttv/stats.h>
27 #include <lttv/lttv.h>
28 #include <lttv/attribute.h>
29 #include <ltt/trace.h>
30 #include <ltt/event.h>
31
32 #define BUF_SIZE 256
33 #define MAX_64_HEX_STRING_LEN 19
34
35 GQuark
36 LTTV_STATS_PROCESS_UNKNOWN,
37 LTTV_STATS_PROCESSES,
38 LTTV_STATS_CPU,
39 LTTV_STATS_MODE_TYPES,
40 LTTV_STATS_MODES,
41 LTTV_STATS_SUBMODES,
42 LTTV_STATS_FUNCTIONS,
43 LTTV_STATS_EVENT_TYPES,
44 LTTV_STATS_CPU_TIME,
45 LTTV_STATS_CUMULATIVE_CPU_TIME,
46 LTTV_STATS_ELAPSED_TIME,
47 LTTV_STATS_EVENTS,
48 LTTV_STATS_EVENTS_COUNT,
49 LTTV_STATS_USE_COUNT,
50 LTTV_STATS,
51 LTTV_STATS_SUMMED,
52 LTTV_STATS_BEFORE_HOOKS,
53 LTTV_STATS_AFTER_HOOKS;
54
55 static void find_event_tree(LttvCPUStats *cpu_stats, GQuark pid_time,
56 guint cpu, guint64 function,
57 GQuark mode, GQuark sub_mode, LttvAttribute **events_tree,
58 LttvAttribute **event_types_tree);
59
60
61 static void lttv_stats_init(LttvTracesetStats *self)
62 {
63 guint i, j, nb_trace, nb_cpu, nb_tracefile;
64
65 LttvTraceContext *tc;
66
67 LttvTraceStats *tcs;
68
69 LttvTracefileContext **tfs;
70 LttvTracefileStats *tfcs;
71 LttvCPUStats *cpu_stats;
72
73 LttvAttributeValue v;
74
75 LttvTraceset *ts = self->parent.parent.ts;
76
77 self->stats = lttv_attribute_find_subdir(
78 lttv_traceset_attribute(self->parent.parent.ts), LTTV_STATS);
79 lttv_attribute_find(lttv_traceset_attribute(self->parent.parent.ts),
80 LTTV_STATS_USE_COUNT,
81 LTTV_UINT, &v);
82
83 (*(v.v_uint))++;
84 if(*(v.v_uint) == 1) {
85 g_assert(lttv_attribute_get_number(self->stats) == 0);
86 }
87
88 nb_trace = lttv_traceset_number(ts);
89
90 for(i = 0 ; i < nb_trace ; i++) {
91 tc = self->parent.parent.traces[i];
92 tcs = LTTV_TRACE_STATS(tc);
93
94 tcs->stats = lttv_attribute_find_subdir(tcs->parent.parent.t_a,
95 LTTV_STATS);
96 lttv_attribute_find(tcs->parent.parent.t_a, LTTV_STATS_USE_COUNT,
97 LTTV_UINT, &v);
98
99 (*(v.v_uint))++;
100 if(*(v.v_uint) == 1) {
101 g_assert(lttv_attribute_get_number(tcs->stats) == 0);
102 }
103
104 nb_cpu = ltt_trace_get_num_cpu(tc->t);
105 tcs->cpu_stats = g_new(LttvCPUStats, nb_cpu);
106 for(j = 0 ; j < nb_cpu; j++) {
107 cpu_stats = &tcs->cpu_stats[j];
108 cpu_stats->cpu = j;
109 cpu_stats->tcs = tcs;
110 find_event_tree(cpu_stats, LTTV_STATS_PROCESS_UNKNOWN,
111 cpu_stats->cpu,
112 0x0ULL,
113 LTTV_STATE_MODE_UNKNOWN,
114 LTTV_STATE_SUBMODE_UNKNOWN, &cpu_stats->current_events_tree,
115 &cpu_stats->current_event_types_tree);
116 }
117 nb_tracefile = tc->tracefiles->len;
118 for (j = 0; j < nb_tracefile; j++) {
119 tfs = &g_array_index(tc->tracefiles, LttvTracefileContext*, j);
120 tfcs = LTTV_TRACEFILE_STATS(*tfs);
121 tfcs->cpu_stats = &tcs->cpu_stats[tfcs->parent.cpu];
122 }
123 }
124
125 }
126
127 static void lttv_stats_fini(LttvTracesetStats *self)
128 {
129 guint i, j, nb_trace, nb_cpu, nb_tracefile;
130
131 LttvTraceset *ts;
132
133 LttvTraceContext *tc;
134
135 LttvTraceStats *tcs;
136
137 LttvTracefileContext *tfc;
138
139 LttvTracefileStats *tfcs;
140
141 LttvCPUStats *cpu_stats;
142
143 LttvAttributeValue v;
144
145 lttv_attribute_find(self->parent.parent.ts_a, LTTV_STATS_USE_COUNT,
146 LTTV_UINT, &v);
147 (*(v.v_uint))--;
148
149 if(*(v.v_uint) == 0) {
150 lttv_attribute_remove_by_name(self->parent.parent.ts_a, LTTV_STATS);
151 }
152 self->stats = NULL;
153
154 ts = self->parent.parent.ts;
155 nb_trace = lttv_traceset_number(ts);
156
157 for(i = 0 ; i < nb_trace ; i++) {
158 tcs = (LttvTraceStats *)(tc = (LTTV_TRACESET_CONTEXT(self)->traces[i]));
159
160 lttv_attribute_find(tcs->parent.parent.t_a, LTTV_STATS_USE_COUNT,
161 LTTV_UINT, &v);
162 (*(v.v_uint))--;
163
164 if(*(v.v_uint) == 0)
165 lttv_attribute_remove_by_name(tcs->parent.parent.t_a, LTTV_STATS);
166 tcs->stats = NULL;
167
168 nb_tracefile = tc->tracefiles->len;
169 for (j = 0; j < nb_tracefile; j++) {
170 tfc = g_array_index(tc->tracefiles, LttvTracefileContext*, j);
171 tfcs = LTTV_TRACEFILE_STATS(tfc);
172 tfcs->cpu_stats = NULL;
173 }
174
175 nb_cpu = ltt_trace_get_num_cpu(tc->t);
176
177 for(j = 0 ; j < nb_cpu; j++) {
178 cpu_stats = &tcs->cpu_stats[j];
179 cpu_stats->current_events_tree = NULL;
180 cpu_stats->current_event_types_tree = NULL;
181 }
182 g_free(tcs->cpu_stats);
183 }
184 }
185
186
187 void lttv_stats_reset(LttvTracesetStats *self)
188 {
189 lttv_stats_fini(self);
190 lttv_stats_init(self);
191 }
192
193
194
195 static void init(LttvTracesetStats *self, LttvTraceset *ts)
196 {
197 LTTV_TRACESET_CONTEXT_CLASS(g_type_class_peek(LTTV_TRACESET_STATE_TYPE))->
198 init((LttvTracesetContext *)self, ts);
199
200 lttv_stats_init(self);
201 }
202
203
204 static void fini(LttvTracesetStats *self)
205 {
206 lttv_stats_fini(self);
207
208 LTTV_TRACESET_CONTEXT_CLASS(g_type_class_peek(LTTV_TRACESET_STATE_TYPE))->
209 fini((LttvTracesetContext *)self);
210 }
211
212
213 static LttvTracesetContext *new_traceset_context(LttvTracesetContext *self)
214 {
215 return LTTV_TRACESET_CONTEXT(g_object_new(LTTV_TRACESET_STATS_TYPE, NULL));
216 }
217
218
219 static LttvTraceContext *new_trace_context(LttvTracesetContext *self)
220 {
221 return LTTV_TRACE_CONTEXT(g_object_new(LTTV_TRACE_STATS_TYPE, NULL));
222 }
223
224
225 static LttvTracefileContext *new_tracefile_context(LttvTracesetContext *self)
226 {
227 return LTTV_TRACEFILE_CONTEXT(g_object_new(LTTV_TRACEFILE_STATS_TYPE, NULL));
228 }
229
230
231 static void traceset_stats_instance_init (GTypeInstance *instance,
232 gpointer g_class)
233 {
234 }
235
236
237 static void traceset_stats_finalize (LttvTracesetStats *self)
238 {
239 G_OBJECT_CLASS(g_type_class_peek(LTTV_TRACESET_STATE_TYPE))->
240 finalize(G_OBJECT(self));
241 }
242
243
244 static void traceset_stats_class_init (LttvTracesetContextClass *klass)
245 {
246 GObjectClass *gobject_class = G_OBJECT_CLASS(klass);
247
248 gobject_class->finalize = (void (*)(GObject *self)) traceset_stats_finalize;
249 klass->init = (void (*)(LttvTracesetContext *self, LttvTraceset *ts))init;
250 klass->fini = (void (*)(LttvTracesetContext *self))fini;
251 klass->new_traceset_context = new_traceset_context;
252 klass->new_trace_context = new_trace_context;
253 klass->new_tracefile_context = new_tracefile_context;
254 }
255
256
257 GType lttv_traceset_stats_get_type(void)
258 {
259 static GType type = 0;
260 if (type == 0) {
261 static const GTypeInfo info = {
262 sizeof (LttvTracesetStatsClass),
263 NULL, /* base_init */
264 NULL, /* base_finalize */
265 (GClassInitFunc) traceset_stats_class_init, /* class_init */
266 NULL, /* class_finalize */
267 NULL, /* class_data */
268 sizeof (LttvTracesetStats),
269 0, /* n_preallocs */
270 (GInstanceInitFunc) traceset_stats_instance_init, /* instance_init */
271 NULL /* Value handling */
272 };
273
274 type = g_type_register_static (LTTV_TRACESET_STATE_TYPE,
275 "LttvTracesetStatsType", &info, 0);
276 }
277 return type;
278 }
279
280
281 static void trace_stats_instance_init (GTypeInstance *instance,
282 gpointer g_class)
283 {
284 }
285
286
287 static void trace_stats_finalize (LttvTraceStats *self)
288 {
289 G_OBJECT_CLASS(g_type_class_peek(LTTV_TRACE_STATE_TYPE))->
290 finalize(G_OBJECT(self));
291 }
292
293
294 static void trace_stats_class_init (LttvTraceContextClass *klass)
295 {
296 GObjectClass *gobject_class = G_OBJECT_CLASS(klass);
297
298 gobject_class->finalize = (void (*)(GObject *self)) trace_stats_finalize;
299 }
300
301
302 GType lttv_trace_stats_get_type(void)
303 {
304 static GType type = 0;
305 if (type == 0) {
306 static const GTypeInfo info = {
307 sizeof (LttvTraceStatsClass),
308 NULL, /* base_init */
309 NULL, /* base_finalize */
310 (GClassInitFunc) trace_stats_class_init, /* class_init */
311 NULL, /* class_finalize */
312 NULL, /* class_data */
313 sizeof (LttvTraceStats),
314 0, /* n_preallocs */
315 (GInstanceInitFunc) trace_stats_instance_init, /* instance_init */
316 NULL /* Value handling */
317 };
318
319 type = g_type_register_static (LTTV_TRACE_STATE_TYPE,
320 "LttvTraceStatsType", &info, 0);
321 }
322 return type;
323 }
324
325
326 static void tracefile_stats_instance_init (GTypeInstance *instance,
327 gpointer g_class)
328 {
329 }
330
331
332 static void tracefile_stats_finalize (LttvTracefileStats *self)
333 {
334 G_OBJECT_CLASS(g_type_class_peek(LTTV_TRACEFILE_STATE_TYPE))->
335 finalize(G_OBJECT(self));
336 }
337
338
339 static void tracefile_stats_class_init (LttvTracefileStatsClass *klass)
340 {
341 GObjectClass *gobject_class = G_OBJECT_CLASS(klass);
342
343 gobject_class->finalize = (void (*)(GObject *self)) tracefile_stats_finalize;
344 }
345
346
347 GType lttv_tracefile_stats_get_type(void)
348 {
349 static GType type = 0;
350 if (type == 0) {
351 static const GTypeInfo info = {
352 sizeof (LttvTracefileStatsClass),
353 NULL, /* base_init */
354 NULL, /* base_finalize */
355 (GClassInitFunc) tracefile_stats_class_init, /* class_init */
356 NULL, /* class_finalize */
357 NULL, /* class_data */
358 sizeof (LttvTracefileStats),
359 0, /* n_preallocs */
360 (GInstanceInitFunc) tracefile_stats_instance_init, /* instance_init */
361 NULL /* Value handling */
362 };
363
364 type = g_type_register_static (LTTV_TRACEFILE_STATE_TYPE,
365 "LttvTracefileStatsType", &info, 0);
366 }
367 return type;
368 }
369
370 static void find_event_tree(LttvCPUStats *cpu_stats,
371 GQuark pid_time,
372 guint cpu,
373 guint64 function,
374 GQuark mode,
375 GQuark sub_mode,
376 LttvAttribute **events_tree,
377 LttvAttribute **event_types_tree)
378 {
379 LttvAttribute *a;
380 gchar fstring[MAX_64_HEX_STRING_LEN];
381 gint ret;
382
383 ret = snprintf(fstring, MAX_64_HEX_STRING_LEN-1,
384 "0x%" PRIX64, function) > 0;
385 g_assert(ret > 0);
386 fstring[MAX_64_HEX_STRING_LEN-1] = '\0';
387
388 LttvTraceStats *tcs = cpu_stats->tcs;
389 a = lttv_attribute_find_subdir(tcs->stats, LTTV_STATS_PROCESSES);
390 a = lttv_attribute_find_subdir(a, pid_time);
391 a = lttv_attribute_find_subdir(a, LTTV_STATS_CPU);
392 a = lttv_attribute_find_subdir_unnamed(a, cpu);
393 a = lttv_attribute_find_subdir(a, LTTV_STATS_FUNCTIONS);
394 a = lttv_attribute_find_subdir(a, g_quark_from_string(fstring));
395 a = lttv_attribute_find_subdir(a, LTTV_STATS_MODE_TYPES);
396 a = lttv_attribute_find_subdir(a, mode);
397 a = lttv_attribute_find_subdir(a, LTTV_STATS_SUBMODES);
398 a = lttv_attribute_find_subdir(a, sub_mode);
399 *events_tree = a;
400 a = lttv_attribute_find_subdir(a, LTTV_STATS_EVENT_TYPES);
401 *event_types_tree = a;
402 }
403
404 static void update_event_tree(LttvCPUStats *cpu_stats)
405 {
406 LttvTraceStats *tcs = cpu_stats->tcs;
407 guint cpu = cpu_stats->cpu;
408 LttvTraceState *ts = &tcs->parent;
409 LttvProcessState *process = ts->running_process[cpu];
410 LttvExecutionState *es = process->state;
411
412 find_event_tree(cpu_stats, process->pid_time,
413 cpu,
414 process->current_function,
415 es->t, es->n, &(cpu_stats->current_events_tree),
416 &(cpu_stats->current_event_types_tree));
417 }
418
419 /* Update the trace event tree each cpu */
420 static void update_trace_event_tree(LttvTraceStats *tcs)
421 {
422 LttvCPUStats *cpu_stats;
423 LttvTraceContext *tc = (LttvTraceContext*)tcs;
424 guint j, nb_cpu;
425
426 /* For each cpu, update the event tree */
427 nb_cpu = ltt_trace_get_num_cpu(tc->t);
428 for(j = 0; j < nb_cpu; j++) {
429 cpu_stats = &tcs->cpu_stats[j];
430 update_event_tree(cpu_stats);
431 }
432 }
433
434 static void mode_change(LttvTracefileStats *tfcs)
435 {
436 LttvTraceState *ts = (LttvTraceState *)tfcs->parent.parent.t_context;
437 guint cpu = tfcs->parent.cpu;
438 LttvProcessState *process = ts->running_process[cpu];
439 LttvAttributeValue cpu_time;
440
441 LttTime delta;
442
443 if(process->state->s == LTTV_STATE_RUN &&
444 process->state->t != LTTV_STATE_MODE_UNKNOWN)
445 delta = ltt_time_sub(tfcs->parent.parent.timestamp,
446 process->state->change);
447 else
448 delta = ltt_time_zero;
449
450 lttv_attribute_find(tfcs->cpu_stats->current_events_tree, LTTV_STATS_CPU_TIME,
451 LTTV_TIME, &cpu_time);
452 *(cpu_time.v_time) = ltt_time_add(*(cpu_time.v_time), delta);
453
454 process->state->cum_cpu_time = ltt_time_add(process->state->cum_cpu_time,
455 delta);
456 }
457
458 /* Note : every mode_end must come with a cumulative cpu time update in the
459 * after hook. */
460 static void mode_end(LttvTracefileStats *tfcs)
461 {
462 LttvTraceState *ts = (LttvTraceState *)tfcs->parent.parent.t_context;
463 guint cpu = tfcs->parent.cpu;
464 LttvProcessState *process = ts->running_process[cpu];
465 LttvAttributeValue elapsed_time, cpu_time, cum_cpu_time;
466
467 LttTime delta;
468
469 /* FIXME put there in case of a missing update after a state modification */
470 //void *lasttree = tfcs->cpu_stats->current_events_tree;
471 //update_event_tree(tfcs);
472 //g_assert (lasttree == tfcs->cpu_stats->current_events_tree);
473 lttv_attribute_find(tfcs->cpu_stats->current_events_tree, LTTV_STATS_ELAPSED_TIME,
474 LTTV_TIME, &elapsed_time);
475
476 if(process->state->t != LTTV_STATE_MODE_UNKNOWN) {
477 delta = ltt_time_sub(tfcs->parent.parent.timestamp,
478 process->state->entry);
479 } else
480 delta = ltt_time_zero;
481
482 *(elapsed_time.v_time) = ltt_time_add(*(elapsed_time.v_time), delta);
483
484 lttv_attribute_find(tfcs->cpu_stats->current_events_tree, LTTV_STATS_CPU_TIME,
485 LTTV_TIME, &cpu_time);
486
487 /* if it is a running mode, we must count its cpu time */
488 if(process->state->s == LTTV_STATE_RUN &&
489 process->state->t != LTTV_STATE_MODE_UNKNOWN)
490 delta = ltt_time_sub(tfcs->parent.parent.timestamp,
491 process->state->change);
492 else
493 delta = ltt_time_zero;
494
495 *(cpu_time.v_time) = ltt_time_add(*(cpu_time.v_time), delta);
496 process->state->cum_cpu_time = ltt_time_add(process->state->cum_cpu_time,
497 delta);
498
499 lttv_attribute_find(tfcs->cpu_stats->current_events_tree, LTTV_STATS_CUMULATIVE_CPU_TIME,
500 LTTV_TIME, &cum_cpu_time);
501 *(cum_cpu_time.v_time) = ltt_time_add(*(cum_cpu_time.v_time),
502 process->state->cum_cpu_time);
503 }
504
505
506 static void after_mode_end(LttvTracefileStats *tfcs)
507 {
508 LttvTraceState *ts = (LttvTraceState *)tfcs->parent.parent.t_context;
509 guint cpu = tfcs->parent.cpu;
510 LttvProcessState *process = ts->running_process[cpu];
511
512 LttTime nested_delta;
513
514 nested_delta = process->state->cum_cpu_time;
515 process->state->cum_cpu_time = ltt_time_zero; /* For after traceset hook */
516
517 update_event_tree(tfcs->cpu_stats);
518
519 process->state->cum_cpu_time = ltt_time_add(process->state->cum_cpu_time,
520 nested_delta);
521 }
522
523 static gboolean before_syscall_entry(void *hook_data, void *call_data)
524 {
525 mode_change((LttvTracefileStats *)call_data);
526 return FALSE;
527 }
528
529
530 static gboolean after_syscall_entry(void *hook_data, void *call_data)
531 {
532 update_event_tree(((LttvTracefileStats *)call_data)->cpu_stats);
533 return FALSE;
534 }
535
536
537 static gboolean before_syscall_exit(void *hook_data, void *call_data)
538 {
539 mode_end((LttvTracefileStats *)call_data);
540 return FALSE;
541 }
542
543
544 static gboolean after_syscall_exit(void *hook_data, void *call_data)
545 {
546 after_mode_end((LttvTracefileStats *)call_data);
547 return FALSE;
548 }
549
550
551 static gboolean before_trap_entry(void *hook_data, void *call_data)
552 {
553 mode_change((LttvTracefileStats *)call_data);
554 return FALSE;
555 }
556
557
558 static gboolean after_trap_entry(void *hook_data, void *call_data)
559 {
560 update_event_tree(((LttvTracefileStats *)call_data)->cpu_stats);
561 return FALSE;
562 }
563
564
565 static gboolean before_trap_exit(void *hook_data, void *call_data)
566 {
567 mode_end((LttvTracefileStats *)call_data);
568 return FALSE;
569 }
570
571
572 static gboolean after_trap_exit(void *hook_data, void *call_data)
573 {
574 after_mode_end((LttvTracefileStats *)call_data);
575 return FALSE;
576 }
577
578
579 static gboolean before_irq_entry(void *hook_data, void *call_data)
580 {
581 mode_change((LttvTracefileStats *)call_data);
582 return FALSE;
583 }
584
585 static gboolean after_irq_entry(void *hook_data, void *call_data)
586 {
587 update_event_tree(((LttvTracefileStats *)call_data)->cpu_stats);
588 return FALSE;
589 }
590
591
592 static gboolean before_irq_exit(void *hook_data, void *call_data)
593 {
594 mode_end((LttvTracefileStats *)call_data);
595 return FALSE;
596 }
597
598
599 static gboolean after_irq_exit(void *hook_data, void *call_data)
600 {
601 after_mode_end((LttvTracefileStats *)call_data);
602 return FALSE;
603 }
604
605
606 static gboolean before_soft_irq_entry(void *hook_data, void *call_data)
607 {
608 mode_change((LttvTracefileStats *)call_data);
609 return FALSE;
610 }
611
612 static gboolean after_soft_irq_entry(void *hook_data, void *call_data)
613 {
614 update_event_tree(((LttvTracefileStats *)call_data)->cpu_stats);
615 return FALSE;
616 }
617
618 static gboolean before_soft_irq_exit(void *hook_data, void *call_data)
619 {
620 mode_end((LttvTracefileStats *)call_data);
621 return FALSE;
622 }
623
624
625 static gboolean after_soft_irq_exit(void *hook_data, void *call_data)
626 {
627 after_mode_end((LttvTracefileStats *)call_data);
628 return FALSE;
629 }
630
631 static gboolean before_function_entry(void *hook_data, void *call_data)
632 {
633 mode_change((LttvTracefileStats *)call_data);
634 return FALSE;
635 }
636
637 static gboolean after_function_entry(void *hook_data, void *call_data)
638 {
639 update_event_tree(((LttvTracefileStats *)call_data)->cpu_stats);
640 return FALSE;
641 }
642
643 static gboolean before_function_exit(void *hook_data, void *call_data)
644 {
645 mode_end((LttvTracefileStats *)call_data);
646 return FALSE;
647 }
648
649 static gboolean after_function_exit(void *hook_data, void *call_data)
650 {
651 after_mode_end((LttvTracefileStats *)call_data);
652 return FALSE;
653 }
654
655
656 static gboolean before_schedchange(void *hook_data, void *call_data)
657 {
658 LttvTracefileStats *tfcs = (LttvTracefileStats *)call_data;
659
660 /* compute the time for the process to schedule out */
661 mode_change(tfcs);
662
663 return FALSE;
664 }
665
666 static gboolean after_schedchange(void *hook_data, void *call_data)
667 {
668 LttvTracefileStats *tfcs = (LttvTracefileStats *)call_data;
669
670 LttvTraceState *ts = (LttvTraceState*)tfcs->parent.parent.t_context;
671
672 LttvProcessState *process;
673
674 /* get the information for the process scheduled in */
675 guint cpu = tfcs->parent.cpu;
676 process = ts->running_process[cpu];
677
678 find_event_tree(tfcs->cpu_stats, process->pid_time,
679 cpu,
680 process->current_function,
681 process->state->t, process->state->n,
682 &(tfcs->cpu_stats->current_events_tree),
683 &(tfcs->cpu_stats->current_event_types_tree));
684
685 /* compute the time waiting for the process to schedule in */
686 mode_change(tfcs);
687
688 return FALSE;
689 }
690
691 static gboolean process_fork(void *hook_data, void *call_data)
692 {
693 return FALSE;
694 }
695
696 static gboolean process_exit(void *hook_data, void *call_data)
697 {
698 update_event_tree(((LttvTracefileStats *)call_data)->cpu_stats);
699 return FALSE;
700 }
701
702 static gboolean before_enum_process_state(void *hook_data, void *call_data)
703 {
704 #if 0
705 /* Broken : adds up time in the current process doing the dump */
706 LttvTracefileStats *tfcs = (LttvTracefileStats *)call_data;
707 mode_end(tfcs);
708 after_mode_end(tfcs);
709 mode_change(tfcs);
710 #endif //0
711 return FALSE;
712 }
713
714 static gboolean after_enum_process_state(void *hook_data, void *call_data)
715 {
716 LttvTracefileContext *tfc = (LttvTracefileContext *)call_data;
717 LttvTraceStats *tcs = (LttvTraceStats*)tfc->t_context;
718 update_trace_event_tree(tcs);
719 return FALSE;
720 }
721
722 static gboolean after_statedump_end(void *hook_data, void *call_data)
723 {
724 LttvTracefileContext *tfc = (LttvTracefileContext *)call_data;
725 LttvTraceStats *tcs = (LttvTraceStats*)tfc->t_context;
726 update_trace_event_tree(tcs);
727 return FALSE;
728 }
729
730 static gboolean process_free(void *hook_data, void *call_data)
731 {
732 return FALSE;
733 }
734
735 static gboolean every_event(void *hook_data, void *call_data)
736 {
737 LttvTracefileStats *tfcs = (LttvTracefileStats *)call_data;
738
739 LttEvent *e = ltt_tracefile_get_event(tfcs->parent.parent.tf);
740
741 LttvAttributeValue v;
742
743 struct marker_info *info;
744
745 /* The current branch corresponds to the tracefile/process/interrupt state.
746 Statistics are added within it, to count the number of events of this
747 type occuring in this context. A quark has been pre-allocated for each
748 event type and is used as name. */
749
750 info = marker_get_info_from_id(tfcs->parent.parent.tf->mdata, e->event_id);
751
752 lttv_attribute_find(tfcs->cpu_stats->current_event_types_tree,
753 info->name, LTTV_UINT, &v);
754 (*(v.v_uint))++;
755 return FALSE;
756 }
757
758 struct cleanup_state_struct {
759 LttvTraceState *ts;
760 LttTime current_time;
761 };
762
763 //static void lttv_stats_cleanup_process_state(LttvTraceState *ts,
764 // LttvProcessState *process, LttTime current_time)
765 static void lttv_stats_cleanup_process_state(gpointer key, gpointer value,
766 gpointer user_data)
767 {
768 struct cleanup_state_struct *cleanup_closure =
769 (struct cleanup_state_struct *)user_data;
770 LttvTraceState *ts = cleanup_closure->ts;
771 LttvProcessState *process = (LttvProcessState *)value;
772 LttTime current_time = cleanup_closure->current_time;
773 LttvTracefileStats **tfs = (LttvTracefileStats **)
774 &g_array_index(ts->parent.tracefiles, LttvTracefileContext*,
775 process->cpu);
776 int cleanup_empty = 0;
777 LttTime nested_delta = ltt_time_zero;
778
779 /* FIXME : ok, this is a hack. The time is infinite here :( */
780 //LttTime save_time = (*tfs)->parent.parent.timestamp;
781 //LttTime start, end;
782 //ltt_trace_time_span_get(ts->parent.t, &start, &end);
783 //(*tfs)->parent.parent.timestamp = end;
784
785 do {
786 if(ltt_time_compare(process->state->cum_cpu_time, ltt_time_zero) != 0) {
787 find_event_tree((*tfs)->cpu_stats, process->pid_time,
788 process->cpu,
789 process->current_function,
790 process->state->t, process->state->n,
791 &((*tfs)->cpu_stats->current_events_tree),
792 &((*tfs)->cpu_stats->current_event_types_tree));
793 /* Call mode_end only if not at end of trace */
794 if(ltt_time_compare(current_time, ltt_time_infinite) != 0)
795 mode_end(*tfs);
796 nested_delta = process->state->cum_cpu_time;
797 }
798 cleanup_empty = lttv_state_pop_state_cleanup(process,
799 (LttvTracefileState *)*tfs);
800 process->state->cum_cpu_time = ltt_time_add(process->state->cum_cpu_time,
801 nested_delta);
802
803 } while(cleanup_empty != 1);
804
805 //(*tfs)->parent.parent.timestamp = save_time;
806 }
807
808 /* For each cpu, for each of their stacked states,
809 * perform sum of needed values. */
810 static void lttv_stats_cleanup_state(LttvTraceStats *tcs, LttTime current_time)
811 {
812 LttvTraceState *ts = (LttvTraceState *)tcs;
813 struct cleanup_state_struct cleanup_closure;
814 #if 0
815 guint nb_cpus, i;
816
817 nb_cpus = ltt_trace_get_num_cpu(ts->parent.t);
818
819 for(i=0; i<nb_cpus; i++) {
820 lttv_stats_cleanup_process_state(ts, ts->running_process[i], current_time);
821 }
822 #endif //0
823 cleanup_closure.ts = ts;
824 cleanup_closure.current_time = current_time;
825 g_hash_table_foreach(ts->processes, lttv_stats_cleanup_process_state,
826 &cleanup_closure);
827 }
828
829 void lttv_stats_sum_trace(LttvTraceStats *self, LttvAttribute *ts_stats,
830 LttTime current_time)
831 {
832 LttvAttribute *sum_container = self->stats;
833
834 LttvAttributeValue value;
835
836 LttvAttributeName name;
837
838 gboolean is_named;
839
840 unsigned sum;
841
842 int trace_is_summed;
843
844 int i, j, k, l, m, nb_process, nb_cpu, nb_mode_type, nb_submode,
845 nb_event_type, nf, nb_functions;
846
847 LttvAttribute *main_tree, *processes_tree, *process_tree, *cpus_tree,
848 *cpu_tree, *mode_tree, *mode_types_tree, *submodes_tree,
849 *submode_tree, *event_types_tree, *mode_events_tree,
850 *cpu_functions_tree,
851 *function_tree,
852 *function_mode_types_tree,
853 *trace_cpu_tree;
854
855
856 main_tree = sum_container;
857
858 lttv_attribute_find(sum_container,
859 LTTV_STATS_SUMMED,
860 LTTV_UINT, &value);
861 trace_is_summed = *(value.v_uint);
862 *(value.v_uint) = 1;
863
864 /* First cleanup the state : sum all stalled information (never ending
865 * states). */
866 if(!trace_is_summed)
867 lttv_stats_cleanup_state(self, current_time);
868
869 processes_tree = lttv_attribute_find_subdir(main_tree,
870 LTTV_STATS_PROCESSES);
871 nb_process = lttv_attribute_get_number(processes_tree);
872
873 for(i = 0 ; i < nb_process ; i++) {
874 lttv_attribute_get(processes_tree, i, &name, &value, &is_named);
875 process_tree = LTTV_ATTRIBUTE(*(value.v_gobject));
876
877 cpus_tree = lttv_attribute_find_subdir(process_tree, LTTV_STATS_CPU);
878 nb_cpu = lttv_attribute_get_number(cpus_tree);
879
880 for(j = 0 ; j < nb_cpu ; j++) {
881 lttv_attribute_get(cpus_tree, j, &name, &value, &is_named);
882 cpu_tree = LTTV_ATTRIBUTE(*(value.v_gobject));
883
884 trace_cpu_tree = lttv_attribute_find_subdir(main_tree,
885 LTTV_STATS_CPU);
886 trace_cpu_tree = lttv_attribute_find_subdir_unnamed(trace_cpu_tree, name);
887 cpu_functions_tree = lttv_attribute_find_subdir(cpu_tree,
888 LTTV_STATS_FUNCTIONS);
889 nb_functions = lttv_attribute_get_number(cpu_functions_tree);
890
891 for(nf=0; nf < nb_functions; nf++) {
892 lttv_attribute_get(cpu_functions_tree, nf, &name, &value,
893 &is_named);
894 function_tree = LTTV_ATTRIBUTE(*(value.v_gobject));
895 function_mode_types_tree = lttv_attribute_find_subdir(function_tree,
896 LTTV_STATS_MODE_TYPES);
897 nb_mode_type = lttv_attribute_get_number(function_mode_types_tree);
898 for(k = 0 ; k < nb_mode_type ; k++) {
899 lttv_attribute_get(function_mode_types_tree, k, &name,
900 &value, &is_named);
901 mode_tree = LTTV_ATTRIBUTE(*(value.v_gobject));
902
903 submodes_tree = lttv_attribute_find_subdir(mode_tree,
904 LTTV_STATS_SUBMODES);
905 mode_events_tree = lttv_attribute_find_subdir(mode_tree,
906 LTTV_STATS_EVENTS);
907 mode_types_tree = lttv_attribute_find_subdir(mode_tree,
908 LTTV_STATS_MODE_TYPES);
909
910 nb_submode = lttv_attribute_get_number(submodes_tree);
911
912 for(l = 0 ; l < nb_submode ; l++) {
913 lttv_attribute_get(submodes_tree, l, &name, &value,
914 &is_named);
915 submode_tree = LTTV_ATTRIBUTE(*(value.v_gobject));
916
917 event_types_tree = lttv_attribute_find_subdir(submode_tree,
918 LTTV_STATS_EVENT_TYPES);
919 nb_event_type = lttv_attribute_get_number(event_types_tree);
920
921 sum = 0;
922 for(m = 0 ; m < nb_event_type ; m++) {
923 lttv_attribute_get(event_types_tree, m, &name,
924 &value, &is_named);
925 sum += *(value.v_uint);
926 }
927 lttv_attribute_find(submode_tree, LTTV_STATS_EVENTS_COUNT,
928 LTTV_UINT, &value);
929 *(value.v_uint) = sum;
930
931 lttv_attribute_get(submodes_tree, l, &name, &value,
932 &is_named);
933 submode_tree = LTTV_ATTRIBUTE(*(value.v_gobject));
934 if(!trace_is_summed) {
935 lttv_attribute_recursive_add(mode_events_tree, event_types_tree);
936 lttv_attribute_recursive_add(mode_types_tree, submode_tree);
937 }
938 }
939 if(!trace_is_summed) {
940 lttv_attribute_recursive_add(function_tree, mode_types_tree);
941 }
942 }
943 if(!trace_is_summed) {
944 lttv_attribute_recursive_add(cpu_tree, function_tree);
945 lttv_attribute_recursive_add(process_tree, function_tree);
946 lttv_attribute_recursive_add(trace_cpu_tree, function_tree);
947 lttv_attribute_recursive_add(main_tree, function_tree);
948 }
949 lttv_attribute_recursive_add(ts_stats, function_tree);
950 }
951 }
952 }
953 }
954
955
956 gboolean lttv_stats_sum_traceset_hook(void *hook_data, void *call_data)
957 {
958 struct sum_traceset_closure *closure =
959 (struct sum_traceset_closure *)call_data;
960 lttv_stats_sum_traceset(closure->tss, closure->current_time);
961 return 0;
962 }
963
964 void lttv_stats_sum_traceset(LttvTracesetStats *self, LttTime current_time)
965 {
966 LttvTraceset *traceset = self->parent.parent.ts;
967 LttvAttribute *sum_container = self->stats;
968
969 LttvTraceStats *tcs;
970
971 int i, nb_trace;
972
973 LttvAttributeValue value;
974
975 lttv_attribute_find(sum_container, LTTV_STATS_SUMMED,
976 LTTV_UINT, &value);
977 if(*(value.v_uint) != 0) return;
978 *(value.v_uint) = 1;
979
980 nb_trace = lttv_traceset_number(traceset);
981
982 for(i = 0 ; i < nb_trace ; i++) {
983 tcs = (LttvTraceStats *)(self->parent.parent.traces[i]);
984 lttv_stats_sum_trace(tcs, self->stats, current_time);
985 // lttv_attribute_recursive_add(sum_container, tcs->stats);
986 }
987 }
988
989
990 // Hook wrapper. call_data is a traceset context.
991 gboolean lttv_stats_hook_add_event_hooks(void *hook_data, void *call_data)
992 {
993 LttvTracesetStats *tss = (LttvTracesetStats*)call_data;
994
995 lttv_stats_add_event_hooks(tss);
996
997 return 0;
998 }
999
1000 void lttv_stats_add_event_hooks(LttvTracesetStats *self)
1001 {
1002 LttvTraceset *traceset = self->parent.parent.ts;
1003
1004 guint i, j, k, nb_trace, nb_tracefile;
1005
1006 LttvTraceStats *ts;
1007
1008 LttvTracefileStats *tfs;
1009
1010 GArray *hooks, *before_hooks, *after_hooks;
1011
1012 LttvTraceHook *th;
1013
1014 LttvAttributeValue val;
1015
1016 nb_trace = lttv_traceset_number(traceset);
1017 for(i = 0 ; i < nb_trace ; i++) {
1018 ts = (LttvTraceStats *)self->parent.parent.traces[i];
1019
1020 /* Find the eventtype id for the following events and register the
1021 associated by id hooks. */
1022
1023 hooks = g_array_sized_new(FALSE, FALSE, sizeof(LttvTraceHook), 12);
1024
1025 lttv_trace_find_hook(ts->parent.parent.t,
1026 LTT_CHANNEL_KERNEL,
1027 LTT_EVENT_SYSCALL_ENTRY,
1028 FIELD_ARRAY(LTT_FIELD_SYSCALL_ID),
1029 before_syscall_entry, NULL,
1030 &hooks);
1031
1032 lttv_trace_find_hook(ts->parent.parent.t,
1033 LTT_CHANNEL_KERNEL,
1034 LTT_EVENT_SYSCALL_EXIT,
1035 NULL,
1036 before_syscall_exit, NULL,
1037 &hooks);
1038
1039 lttv_trace_find_hook(ts->parent.parent.t,
1040 LTT_CHANNEL_KERNEL,
1041 LTT_EVENT_TRAP_ENTRY,
1042 FIELD_ARRAY(LTT_FIELD_TRAP_ID),
1043 before_trap_entry, NULL,
1044 &hooks);
1045
1046 lttv_trace_find_hook(ts->parent.parent.t,
1047 LTT_CHANNEL_KERNEL,
1048 LTT_EVENT_TRAP_EXIT,
1049 NULL,
1050 before_trap_exit, NULL,
1051 &hooks);
1052
1053 lttv_trace_find_hook(ts->parent.parent.t,
1054 LTT_CHANNEL_KERNEL,
1055 LTT_EVENT_IRQ_ENTRY,
1056 FIELD_ARRAY(LTT_FIELD_IRQ_ID),
1057 before_irq_entry, NULL,
1058 &hooks);
1059
1060 lttv_trace_find_hook(ts->parent.parent.t,
1061 LTT_CHANNEL_KERNEL,
1062 LTT_EVENT_IRQ_EXIT,
1063 NULL,
1064 before_irq_exit, NULL,
1065 &hooks);
1066
1067 lttv_trace_find_hook(ts->parent.parent.t,
1068 LTT_CHANNEL_KERNEL,
1069 LTT_EVENT_SOFT_IRQ_ENTRY,
1070 FIELD_ARRAY(LTT_FIELD_SOFT_IRQ_ID),
1071 before_soft_irq_entry, NULL,
1072 &hooks);
1073
1074 lttv_trace_find_hook(ts->parent.parent.t,
1075 LTT_CHANNEL_KERNEL,
1076 LTT_EVENT_SOFT_IRQ_EXIT,
1077 NULL,
1078 before_soft_irq_exit, NULL,
1079 &hooks);
1080
1081 lttv_trace_find_hook(ts->parent.parent.t,
1082 LTT_CHANNEL_KERNEL,
1083 LTT_EVENT_SCHED_SCHEDULE,
1084 FIELD_ARRAY(LTT_FIELD_PREV_PID, LTT_FIELD_NEXT_PID, LTT_FIELD_PREV_STATE),
1085 before_schedchange, NULL,
1086 &hooks);
1087
1088 lttv_trace_find_hook(ts->parent.parent.t,
1089 LTT_CHANNEL_USERSPACE,
1090 LTT_EVENT_FUNCTION_ENTRY,
1091 FIELD_ARRAY(LTT_FIELD_THIS_FN, LTT_FIELD_CALL_SITE),
1092 before_function_entry, NULL,
1093 &hooks);
1094
1095 lttv_trace_find_hook(ts->parent.parent.t,
1096 LTT_CHANNEL_USERSPACE,
1097 LTT_EVENT_FUNCTION_EXIT,
1098 FIELD_ARRAY(LTT_FIELD_THIS_FN, LTT_FIELD_CALL_SITE),
1099 before_function_exit, NULL,
1100 &hooks);
1101
1102 /* statedump-related hooks */
1103 lttv_trace_find_hook(ts->parent.parent.t,
1104 LTT_CHANNEL_TASK_STATE,
1105 LTT_EVENT_PROCESS_STATE,
1106 FIELD_ARRAY(LTT_FIELD_PID, LTT_FIELD_PARENT_PID, LTT_FIELD_NAME),
1107 before_enum_process_state, NULL,
1108 &hooks);
1109
1110 before_hooks = hooks;
1111
1112 hooks = g_array_sized_new(FALSE, FALSE, sizeof(LttvTraceHook), 16);
1113
1114 lttv_trace_find_hook(ts->parent.parent.t,
1115 LTT_CHANNEL_KERNEL,
1116 LTT_EVENT_SYSCALL_ENTRY,
1117 FIELD_ARRAY(LTT_FIELD_SYSCALL_ID),
1118 after_syscall_entry, NULL,
1119 &hooks);
1120
1121 lttv_trace_find_hook(ts->parent.parent.t,
1122 LTT_CHANNEL_KERNEL,
1123 LTT_EVENT_SYSCALL_EXIT,
1124 NULL,
1125 after_syscall_exit, NULL,
1126 &hooks);
1127
1128 lttv_trace_find_hook(ts->parent.parent.t,
1129 LTT_CHANNEL_KERNEL,
1130 LTT_EVENT_TRAP_ENTRY,
1131 FIELD_ARRAY(LTT_FIELD_TRAP_ID),
1132 after_trap_entry, NULL,
1133 &hooks);
1134
1135 lttv_trace_find_hook(ts->parent.parent.t,
1136 LTT_CHANNEL_KERNEL,
1137 LTT_EVENT_TRAP_EXIT,
1138 NULL,
1139 after_trap_exit, NULL,
1140 &hooks);
1141
1142 lttv_trace_find_hook(ts->parent.parent.t,
1143 LTT_CHANNEL_KERNEL,
1144 LTT_EVENT_IRQ_ENTRY,
1145 FIELD_ARRAY(LTT_FIELD_IRQ_ID),
1146 after_irq_entry, NULL,
1147 &hooks);
1148
1149 lttv_trace_find_hook(ts->parent.parent.t,
1150 LTT_CHANNEL_KERNEL,
1151 LTT_EVENT_IRQ_EXIT,
1152 NULL,
1153 after_irq_exit, NULL,
1154 &hooks);
1155
1156 lttv_trace_find_hook(ts->parent.parent.t,
1157 LTT_CHANNEL_KERNEL,
1158 LTT_EVENT_SOFT_IRQ_ENTRY,
1159 FIELD_ARRAY(LTT_FIELD_SOFT_IRQ_ID),
1160 after_soft_irq_entry, NULL,
1161 &hooks);
1162
1163 lttv_trace_find_hook(ts->parent.parent.t,
1164 LTT_CHANNEL_KERNEL,
1165 LTT_EVENT_SOFT_IRQ_EXIT,
1166 NULL,
1167 after_soft_irq_exit, NULL,
1168 &hooks);
1169
1170 lttv_trace_find_hook(ts->parent.parent.t,
1171 LTT_CHANNEL_KERNEL,
1172 LTT_EVENT_SCHED_SCHEDULE,
1173 FIELD_ARRAY(LTT_FIELD_PREV_PID, LTT_FIELD_NEXT_PID, LTT_FIELD_PREV_STATE),
1174 after_schedchange, NULL,
1175 &hooks);
1176
1177 lttv_trace_find_hook(ts->parent.parent.t,
1178 LTT_CHANNEL_KERNEL,
1179 LTT_EVENT_PROCESS_FORK,
1180 FIELD_ARRAY(LTT_FIELD_PARENT_PID, LTT_FIELD_CHILD_PID),
1181 process_fork, NULL,
1182 &hooks);
1183
1184 lttv_trace_find_hook(ts->parent.parent.t,
1185 LTT_CHANNEL_KERNEL,
1186 LTT_EVENT_PROCESS_EXIT,
1187 FIELD_ARRAY(LTT_FIELD_PID),
1188 process_exit, NULL,
1189 &hooks);
1190
1191 lttv_trace_find_hook(ts->parent.parent.t,
1192 LTT_CHANNEL_KERNEL,
1193 LTT_EVENT_PROCESS_FREE,
1194 FIELD_ARRAY(LTT_FIELD_PID),
1195 process_free, NULL,
1196 &hooks);
1197
1198 lttv_trace_find_hook(ts->parent.parent.t,
1199 LTT_CHANNEL_USERSPACE,
1200 LTT_EVENT_FUNCTION_ENTRY,
1201 FIELD_ARRAY(LTT_FIELD_THIS_FN, LTT_FIELD_CALL_SITE),
1202 after_function_entry, NULL,
1203 &hooks);
1204
1205 lttv_trace_find_hook(ts->parent.parent.t,
1206 LTT_CHANNEL_USERSPACE,
1207 LTT_EVENT_FUNCTION_EXIT,
1208 FIELD_ARRAY(LTT_FIELD_THIS_FN, LTT_FIELD_CALL_SITE),
1209 after_function_exit, NULL,
1210 &hooks);
1211
1212 /* statedump-related hooks */
1213 lttv_trace_find_hook(ts->parent.parent.t,
1214 LTT_CHANNEL_TASK_STATE,
1215 LTT_EVENT_PROCESS_STATE,
1216 FIELD_ARRAY(LTT_FIELD_PID, LTT_FIELD_PARENT_PID, LTT_FIELD_NAME),
1217 after_enum_process_state, NULL,
1218 &hooks);
1219
1220 lttv_trace_find_hook(ts->parent.parent.t,
1221 LTT_CHANNEL_GLOBAL_STATE,
1222 LTT_EVENT_STATEDUMP_END,
1223 NULL,
1224 after_statedump_end, NULL,
1225 &hooks);
1226
1227 after_hooks = hooks;
1228
1229 /* Add these hooks to each event_by_id hooks list */
1230
1231 nb_tracefile = ts->parent.parent.tracefiles->len;
1232
1233 for(j = 0 ; j < nb_tracefile ; j++) {
1234 tfs = LTTV_TRACEFILE_STATS(g_array_index(ts->parent.parent.tracefiles,
1235 LttvTracefileContext*, j));
1236 lttv_hooks_add(tfs->parent.parent.event, every_event, NULL,
1237 LTTV_PRIO_DEFAULT);
1238
1239 for(k = 0 ; k < before_hooks->len ; k++) {
1240 th = &g_array_index(before_hooks, LttvTraceHook, k);
1241 if (th->mdata == tfs->parent.parent.tf->mdata)
1242 lttv_hooks_add(
1243 lttv_hooks_by_id_find(tfs->parent.parent.event_by_id, th->id),
1244 th->h,
1245 th,
1246 LTTV_PRIO_STATS_BEFORE_STATE);
1247 }
1248 for(k = 0 ; k < after_hooks->len ; k++) {
1249 th = &g_array_index(after_hooks, LttvTraceHook, k);
1250 if (th->mdata == tfs->parent.parent.tf->mdata)
1251 lttv_hooks_add(
1252 lttv_hooks_by_id_find(tfs->parent.parent.event_by_id, th->id),
1253 th->h,
1254 th,
1255 LTTV_PRIO_STATS_AFTER_STATE);
1256 }
1257 }
1258 lttv_attribute_find(self->parent.parent.a, LTTV_STATS_BEFORE_HOOKS,
1259 LTTV_POINTER, &val);
1260 *(val.v_pointer) = before_hooks;
1261 lttv_attribute_find(self->parent.parent.a, LTTV_STATS_AFTER_HOOKS,
1262 LTTV_POINTER, &val);
1263 *(val.v_pointer) = after_hooks;
1264 }
1265 }
1266
1267 // Hook wrapper. call_data is a traceset context.
1268 gboolean lttv_stats_hook_remove_event_hooks(void *hook_data, void *call_data)
1269 {
1270 LttvTracesetStats *tss = (LttvTracesetStats*)call_data;
1271
1272 lttv_stats_remove_event_hooks(tss);
1273
1274 return 0;
1275 }
1276
1277 void lttv_stats_remove_event_hooks(LttvTracesetStats *self)
1278 {
1279 LttvTraceset *traceset = self->parent.parent.ts;
1280
1281 guint i, j, k, nb_trace, nb_tracefile;
1282
1283 LttvTraceStats *ts;
1284
1285 LttvTracefileStats *tfs;
1286
1287 GArray *before_hooks, *after_hooks;
1288
1289 LttvTraceHook *th;
1290
1291 LttvAttributeValue val;
1292
1293 nb_trace = lttv_traceset_number(traceset);
1294 for(i = 0 ; i < nb_trace ; i++) {
1295 ts = (LttvTraceStats*)self->parent.parent.traces[i];
1296 lttv_attribute_find(self->parent.parent.a, LTTV_STATS_BEFORE_HOOKS,
1297 LTTV_POINTER, &val);
1298 before_hooks = *(val.v_pointer);
1299 lttv_attribute_find(self->parent.parent.a, LTTV_STATS_AFTER_HOOKS,
1300 LTTV_POINTER, &val);
1301 after_hooks = *(val.v_pointer);
1302
1303 /* Remove these hooks from each event_by_id hooks list */
1304
1305 nb_tracefile = ts->parent.parent.tracefiles->len;
1306
1307 for(j = 0 ; j < nb_tracefile ; j++) {
1308 tfs = LTTV_TRACEFILE_STATS(g_array_index(ts->parent.parent.tracefiles,
1309 LttvTracefileContext*, j));
1310 lttv_hooks_remove_data(tfs->parent.parent.event, every_event,
1311 NULL);
1312
1313 for(k = 0 ; k < before_hooks->len ; k++) {
1314 th = &g_array_index(before_hooks, LttvTraceHook, k);
1315 if (th->mdata == tfs->parent.parent.tf->mdata)
1316 lttv_hooks_remove_data(
1317 lttv_hooks_by_id_find(tfs->parent.parent.event_by_id, th->id),
1318 th->h,
1319 th);
1320 }
1321 for(k = 0 ; k < after_hooks->len ; k++) {
1322 th = &g_array_index(after_hooks, LttvTraceHook, k);
1323 if (th->mdata == tfs->parent.parent.tf->mdata)
1324 lttv_hooks_remove_data(
1325 lttv_hooks_by_id_find(tfs->parent.parent.event_by_id, th->id),
1326 th->h,
1327 th);
1328
1329 }
1330 }
1331 g_debug("lttv_stats_remove_event_hooks()");
1332 lttv_trace_hook_remove_all(&before_hooks);
1333 lttv_trace_hook_remove_all(&after_hooks);
1334 g_array_free(before_hooks, TRUE);
1335 g_array_free(after_hooks, TRUE);
1336 }
1337 }
1338
1339
1340 static void module_init()
1341 {
1342 LTTV_STATS_PROCESS_UNKNOWN = g_quark_from_string("unknown process");
1343 LTTV_STATS_PROCESSES = g_quark_from_string("processes");
1344 LTTV_STATS_CPU = g_quark_from_string("cpu");
1345 LTTV_STATS_MODE_TYPES = g_quark_from_string("mode_types");
1346 LTTV_STATS_MODES = g_quark_from_string("modes");
1347 LTTV_STATS_SUBMODES = g_quark_from_string("submodes");
1348 LTTV_STATS_FUNCTIONS = g_quark_from_string("functions");
1349 LTTV_STATS_EVENT_TYPES = g_quark_from_string("event_types");
1350 LTTV_STATS_CPU_TIME = g_quark_from_string("cpu time");
1351 LTTV_STATS_CUMULATIVE_CPU_TIME = g_quark_from_string("cumulative cpu time (includes nested routines and modes)");
1352 LTTV_STATS_ELAPSED_TIME = g_quark_from_string("elapsed time (includes per process waiting time)");
1353 LTTV_STATS_EVENTS = g_quark_from_string("events");
1354 LTTV_STATS_EVENTS_COUNT = g_quark_from_string("events count");
1355 LTTV_STATS_BEFORE_HOOKS = g_quark_from_string("saved stats before hooks");
1356 LTTV_STATS_AFTER_HOOKS = g_quark_from_string("saved stats after hooks");
1357 LTTV_STATS_USE_COUNT = g_quark_from_string("stats_use_count");
1358 LTTV_STATS = g_quark_from_string("statistics");
1359 LTTV_STATS_SUMMED = g_quark_from_string("statistics summed");
1360 }
1361
1362 static void module_destroy()
1363 {
1364 }
1365
1366
1367 LTTV_MODULE("stats", "Compute processes statistics", \
1368 "Accumulate statistics for event types, processes and CPUs", \
1369 module_init, module_destroy, "state");
1370
1371 /* Change the places where stats are called (create/read/write stats)
1372
1373 Check for options in batchtest.c to reduce writing and see what tests are
1374 best candidates for performance analysis. Once OK, commit, move to main
1375 and run tests. Update the gui for statistics. */
LTTng 2.x Viewer (LTTV)
This page took 0.059833 seconds and 4 git commands to generate.