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