ltt/branches/poly/lttv/modules/gui/controlflow/processlist.c

   1 /* This file is part of the Linux Trace Toolkit viewer
   2  * Copyright (C) 2003-2004 Mathieu Desnoyers
   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 #include <gtk/gtk.h>
  20 #include <glib.h>
  21 #include <string.h>
  22 #include <stdlib.h>
  23
  24 #include "processlist.h"
  25 #include "drawitem.h"
  26
  27 #define g_info(format...) g_log (G_LOG_DOMAIN, G_LOG_LEVEL_INFO, format)
  28 #define g_debug(format...) g_log (G_LOG_DOMAIN, G_LOG_LEVEL_DEBUG, format)
  29
  30
  31 /*****************************************************************************
  32  *                       Methods to synchronize process list                 *
  33  *****************************************************************************/
  34
  35 static __inline guint get_cpu_number_from_name(GQuark name);
  36
  37 /* Enumeration of the columns */
  38 enum
  39 {
  40   PROCESS_COLUMN,
  41   PID_COLUMN,
  42   PPID_COLUMN,
  43   CPU_COLUMN,
  44   BIRTH_S_COLUMN,
  45   BIRTH_NS_COLUMN,
  46   TRACE_COLUMN,
  47   N_COLUMNS
  48 };
  49
  50
  51 gint process_sort_func  ( GtkTreeModel *model,
  52         GtkTreeIter *it_a,
  53         GtkTreeIter *it_b,
  54         gpointer user_data)
  55 {
  56   GValue a, b;
  57
  58   memset(&a, 0, sizeof(GValue));
  59   memset(&b, 0, sizeof(GValue));
  60
  61   /* Order by PID */
  62   gtk_tree_model_get_value( model,
  63           it_a,
  64           PID_COLUMN,
  65           &a);
  66
  67   gtk_tree_model_get_value( model,
  68           it_b,
  69           PID_COLUMN,
  70           &b);
  71
  72   if(G_VALUE_TYPE(&a) == G_TYPE_UINT
  73     && G_VALUE_TYPE(&b) == G_TYPE_UINT )
  74   {
  75     {
  76
  77       if(g_value_get_uint(&a) == 0 &&  g_value_get_uint(&b) == 0) {
  78
  79         GValue cpua, cpub;
  80
  81         memset(&cpua, 0, sizeof(GValue));
  82         memset(&cpub, 0, sizeof(GValue));
  83
  84         /* If 0, order by CPU */
  85         gtk_tree_model_get_value( model,
  86                 it_a,
  87                 CPU_COLUMN,
  88                 &cpua);
  89
  90         gtk_tree_model_get_value( model,
  91                 it_b,
  92                 CPU_COLUMN,
  93                 &cpub);
  94
  95         if(G_VALUE_TYPE(&cpua) == G_TYPE_UINT
  96           && G_VALUE_TYPE(&cpub) == G_TYPE_UINT )
  97         {
  98           if(g_value_get_uint(&cpua) > g_value_get_uint(&cpub))
  99           {
 100             g_value_unset(&cpua);
 101             g_value_unset(&cpub);
 102             return 1;
 103           }
 104           if(g_value_get_uint(&cpua) < g_value_get_uint(&cpub))
 105           {
 106             g_value_unset(&cpua);
 107             g_value_unset(&cpub);
 108             return 0;
 109           }
 110         }
 111
 112         g_value_unset(&cpua);
 113         g_value_unset(&cpub);
 114
 115       } else { /* if not 0, order by pid */
 116
 117         if(g_value_get_uint(&a) > g_value_get_uint(&b))
 118         {
 119           g_value_unset(&a);
 120           g_value_unset(&b);
 121           return 1;
 122         }
 123         if(g_value_get_uint(&a) < g_value_get_uint(&b))
 124         {
 125           g_value_unset(&a);
 126           g_value_unset(&b);
 127           return 0;
 128         }
 129       }
 130     }
 131   }
 132
 133   g_value_unset(&a);
 134   g_value_unset(&b);
 135
 136
 137   /* Order by birth second */
 138   gtk_tree_model_get_value( model,
 139           it_a,
 140           BIRTH_S_COLUMN,
 141           &a);
 142
 143   gtk_tree_model_get_value( model,
 144           it_b,
 145           BIRTH_S_COLUMN,
 146           &b);
 147
 148
 149   if(G_VALUE_TYPE(&a) == G_TYPE_ULONG
 150     && G_VALUE_TYPE(&b) == G_TYPE_ULONG )
 151   {
 152     if(g_value_get_ulong(&a) > g_value_get_ulong(&b))
 153     {
 154       g_value_unset(&a);
 155       g_value_unset(&b);
 156       return 1;
 157     }
 158     if(g_value_get_ulong(&a) < g_value_get_ulong(&b))
 159     {
 160       g_value_unset(&a);
 161       g_value_unset(&b);
 162       return 0;
 163     }
 164
 165   }
 166
 167   g_value_unset(&a);
 168   g_value_unset(&b);
 169
 170   /* Order by birth nanosecond */
 171   gtk_tree_model_get_value( model,
 172           it_a,
 173           BIRTH_NS_COLUMN,
 174           &a);
 175
 176   gtk_tree_model_get_value( model,
 177           it_b,
 178           BIRTH_NS_COLUMN,
 179           &b);
 180
 181
 182   if(G_VALUE_TYPE(&a) == G_TYPE_ULONG
 183     && G_VALUE_TYPE(&b) == G_TYPE_ULONG )
 184   {
 185     if(g_value_get_ulong(&a) > g_value_get_ulong(&b))
 186     {
 187       g_value_unset(&a);
 188       g_value_unset(&b);
 189       return 1;
 190     }
 191     if(g_value_get_ulong(&a) < g_value_get_ulong(&b))
 192     {
 193       g_value_unset(&a);
 194       g_value_unset(&b);
 195       return 0;
 196     }
 197
 198   }
 199
 200   g_value_unset(&a);
 201   g_value_unset(&b);
 202
 203   /* Order by trace_num */
 204   gtk_tree_model_get_value( model,
 205           it_a,
 206           TRACE_COLUMN,
 207           &a);
 208
 209   gtk_tree_model_get_value( model,
 210           it_b,
 211           TRACE_COLUMN,
 212           &b);
 213
 214   if(G_VALUE_TYPE(&a) == G_TYPE_ULONG
 215     && G_VALUE_TYPE(&b) == G_TYPE_ULONG )
 216   {
 217     if(g_value_get_ulong(&a) > g_value_get_ulong(&b))
 218     {
 219       g_value_unset(&a);
 220       g_value_unset(&b);
 221       return 1;
 222     }
 223     if(g_value_get_ulong(&a) < g_value_get_ulong(&b))
 224     {
 225       g_value_unset(&a);
 226       g_value_unset(&b);
 227       return 0;
 228     }
 229
 230   }
 231
 232   return 0;
 233
 234 }
 235
 236 static guint process_list_hash_fct(gconstpointer key)
 237 {
 238   guint pid = ((ProcessInfo*)key)->pid;
 239   return ((pid>>8 ^ pid>>4 ^ pid>>2 ^ pid) ^ ((ProcessInfo*)key)->cpu);
 240 }
 241
 242 static gboolean process_list_equ_fct(gconstpointer a, gconstpointer b)
 243 {
 244   const ProcessInfo *pa = (const ProcessInfo*)a;
 245   const ProcessInfo *pb = (const ProcessInfo*)b;
 246
 247   if(pa->pid != pb->pid)
 248     return 0;
 249
 250   if((pa->pid == 0 && (pa->cpu != pb->cpu)))
 251     return 0;
 252
 253   if(pa->birth.tv_sec != pb->birth.tv_sec)
 254     return 0;
 255
 256   if(pa->birth.tv_nsec != pb->birth.tv_nsec)
 257     return 0;
 258
 259   if(pa->trace_num != pb->trace_num)
 260     return 0;
 261
 262   return 1;
 263 }
 264
 265 void destroy_hash_key(gpointer key);
 266
 267 void destroy_hash_data(gpointer data);
 268
 269
 270
 271
 272 ProcessList *processlist_construct(void)
 273 {
 274   GtkTreeViewColumn *column;
 275   GtkCellRenderer *renderer;
 276
 277   ProcessList* process_list = g_new(ProcessList,1);
 278
 279   process_list->number_of_process = 0;
 280   process_list->cell_height_cache = -1;
 281
 282   /* Create the Process list */
 283   process_list->list_store = gtk_list_store_new (  N_COLUMNS,
 284               G_TYPE_STRING,
 285               G_TYPE_UINT,
 286               G_TYPE_UINT,
 287               G_TYPE_UINT,
 288               G_TYPE_ULONG,
 289               G_TYPE_ULONG,
 290               G_TYPE_ULONG);
 291
 292
 293   process_list->process_list_widget =
 294     gtk_tree_view_new_with_model
 295     (GTK_TREE_MODEL (process_list->list_store));
 296   g_object_unref (G_OBJECT (process_list->list_store));
 297
 298   gtk_tree_sortable_set_sort_func(
 299       GTK_TREE_SORTABLE(process_list->list_store),
 300       PID_COLUMN,
 301       process_sort_func,
 302       NULL,
 303       NULL);
 304
 305   gtk_tree_sortable_set_sort_column_id(
 306       GTK_TREE_SORTABLE(process_list->list_store),
 307       PID_COLUMN,
 308       GTK_SORT_ASCENDING);
 309
 310   process_list->process_hash = g_hash_table_new_full(
 311       process_list_hash_fct, process_list_equ_fct,
 312       destroy_hash_key, destroy_hash_data
 313       );
 314
 315
 316   gtk_tree_view_set_headers_visible(
 317     GTK_TREE_VIEW(process_list->process_list_widget), TRUE);
 318
 319   /* Create a column, associating the "text" attribute of the
 320    * cell_renderer to the first column of the model */
 321   /* Columns alignment : 0.0 : Left    0.5 : Center   1.0 : Right */
 322   renderer = gtk_cell_renderer_text_new ();
 323   column = gtk_tree_view_column_new_with_attributes ( "Process",
 324                 renderer,
 325                 "text",
 326                 PROCESS_COLUMN,
 327                 NULL);
 328   gtk_tree_view_column_set_alignment (column, 0.0);
 329   gtk_tree_view_column_set_fixed_width (column, 45);
 330   gtk_tree_view_append_column (
 331     GTK_TREE_VIEW (process_list->process_list_widget), column);
 332
 333   process_list->button = column->button;
 334
 335   column = gtk_tree_view_column_new_with_attributes ( "PID",
 336                 renderer,
 337                 "text",
 338                 PID_COLUMN,
 339                 NULL);
 340   gtk_tree_view_append_column (
 341     GTK_TREE_VIEW (process_list->process_list_widget), column);
 342
 343   column = gtk_tree_view_column_new_with_attributes ( "PPID",
 344                 renderer,
 345                 "text",
 346                 PPID_COLUMN,
 347                 NULL);
 348   gtk_tree_view_append_column (
 349     GTK_TREE_VIEW (process_list->process_list_widget), column);
 350
 351   column = gtk_tree_view_column_new_with_attributes ( "CPU",
 352                 renderer,
 353                 "text",
 354                 CPU_COLUMN,
 355                 NULL);
 356   gtk_tree_view_append_column (
 357     GTK_TREE_VIEW (process_list->process_list_widget), column);
 358
 359   column = gtk_tree_view_column_new_with_attributes ( "Birth sec",
 360                 renderer,
 361                 "text",
 362                 BIRTH_S_COLUMN,
 363                 NULL);
 364   gtk_tree_view_append_column (
 365     GTK_TREE_VIEW (process_list->process_list_widget), column);
 366
 367   //gtk_tree_view_column_set_visible(column, 0);
 368   //
 369   column = gtk_tree_view_column_new_with_attributes ( "Birth nsec",
 370                 renderer,
 371                 "text",
 372                 BIRTH_NS_COLUMN,
 373                 NULL);
 374   gtk_tree_view_append_column (
 375     GTK_TREE_VIEW (process_list->process_list_widget), column);
 376
 377   column = gtk_tree_view_column_new_with_attributes ( "TRACE",
 378                 renderer,
 379                 "text",
 380                 TRACE_COLUMN,
 381                 NULL);
 382   gtk_tree_view_append_column (
 383     GTK_TREE_VIEW (process_list->process_list_widget), column);
 384
 385
 386   //gtk_tree_view_column_set_visible(column, 0);
 387
 388   g_object_set_data_full(
 389       G_OBJECT(process_list->process_list_widget),
 390       "process_list_Data",
 391       process_list,
 392       (GDestroyNotify)processlist_destroy);
 393
 394   return process_list;
 395 }
 396
 397 void processlist_destroy(ProcessList *process_list)
 398 {
 399   g_debug("processlist_destroy %p", process_list);
 400   g_hash_table_destroy(process_list->process_hash);
 401   process_list->process_hash = NULL;
 402
 403   g_free(process_list);
 404   g_debug("processlist_destroy end");
 405 }
 406
 407 static gboolean remove_hash_item(ProcessInfo *process_info,
 408                                  HashedProcessData *hashed_process_data,
 409                                  ProcessList *process_list)
 410 {
 411   GtkTreeIter iter;
 412
 413   iter = hashed_process_data->y_iter;
 414
 415   gtk_list_store_remove (process_list->list_store, &iter);
 416
 417   return TRUE; /* remove the element from the hash table */
 418 }
 419
 420 void processlist_clear(ProcessList *process_list)
 421 {
 422   g_info("processlist_clear %p", process_list);
 423
 424   g_hash_table_foreach_remove(process_list->process_hash,
 425                               (GHRFunc)remove_hash_item,
 426                               (gpointer)process_list);
 427   process_list->number_of_process = 0;
 428 }
 429
 430
 431 GtkWidget *processlist_get_widget(ProcessList *process_list)
 432 {
 433   return process_list->process_list_widget;
 434 }
 435
 436
 437
 438 static __inline gint get_cell_height(ProcessList *process_list, GtkTreeView *tree_view)
 439 {
 440   gint height = process_list->cell_height_cache;
 441   if(height != -1) return height;
 442   else {
 443     GtkTreeViewColumn *Column = gtk_tree_view_get_column(tree_view, 0);
 444
 445     gtk_tree_view_column_cell_get_size(Column, NULL, NULL, NULL, NULL,
 446                                        &process_list->cell_height_cache);
 447   }
 448
 449
 450   return process_list->cell_height_cache;
 451 }
 452
 453 void destroy_hash_key(gpointer key)
 454 {
 455   g_free(key);
 456 }
 457
 458 void destroy_hash_data(gpointer data)
 459 {
 460   g_free(data);
 461 }
 462
 463 int processlist_add(  ProcessList *process_list,
 464       guint pid,
 465       guint cpu,
 466       guint ppid,
 467       LttTime *birth,
 468       guint trace_num,
 469       const gchar *name,
 470       guint *height,
 471       HashedProcessData **pm_hashed_process_data)
 472 {
 473   ProcessInfo *Process_Info = g_new(ProcessInfo, 1);
 474   HashedProcessData *hashed_process_data = g_new(HashedProcessData, 1);
 475   *pm_hashed_process_data = hashed_process_data;
 476
 477   Process_Info->pid = pid;
 478   if(pid == 0)
 479     Process_Info->cpu = cpu;
 480   else
 481     Process_Info->cpu = 0;
 482   Process_Info->ppid = ppid;
 483   Process_Info->birth = *birth;
 484   Process_Info->trace_num = trace_num;
 485
 486   /* When we create it from before state update, we are sure that the
 487    * last event occured before the beginning of the global area.
 488    *
 489    * If it is created after state update, this value (0) will be
 490    * overriden by the new state before anything is drawn.
 491    */
 492   hashed_process_data->x.over = 0;
 493   hashed_process_data->x.over_used = FALSE;
 494   hashed_process_data->x.over_marked = FALSE;
 495   hashed_process_data->x.middle = 0;
 496   hashed_process_data->x.middle_used = FALSE;
 497   hashed_process_data->x.middle_marked = FALSE;
 498   hashed_process_data->x.under = 0;
 499   hashed_process_data->x.under_used = FALSE;
 500   hashed_process_data->x.under_marked = FALSE;
 501   hashed_process_data->next_good_time = ltt_time_zero;
 502
 503   /* Add a new row to the model */
 504   gtk_list_store_append ( process_list->list_store,
 505                           &hashed_process_data->y_iter);
 506
 507   gtk_list_store_set (  process_list->list_store, &hashed_process_data->y_iter,
 508         PROCESS_COLUMN, name,
 509         PID_COLUMN, pid,
 510         PPID_COLUMN, ppid,
 511         CPU_COLUMN, get_cpu_number_from_name(cpu),
 512         BIRTH_S_COLUMN, birth->tv_sec,
 513         BIRTH_NS_COLUMN, birth->tv_nsec,
 514         TRACE_COLUMN, trace_num,
 515         -1);
 516 #if 0
 517   hashed_process_data->row_ref = gtk_tree_row_reference_new (
 518       GTK_TREE_MODEL(process_list->list_store),
 519       gtk_tree_model_get_path(
 520         GTK_TREE_MODEL(process_list->list_store),
 521         &iter));
 522 #endif //0
 523   g_hash_table_insert(process_list->process_hash,
 524         (gpointer)Process_Info,
 525         (gpointer)hashed_process_data);
 526
 527   //g_critical ( "iter after : %s", gtk_tree_path_to_string (
 528   //    gtk_tree_model_get_path (
 529   //        GTK_TREE_MODEL(process_list->list_store),
 530   //        &iter)));
 531   process_list->number_of_process++;
 532
 533   *height = get_cell_height(process_list,
 534                             GTK_TREE_VIEW(process_list->process_list_widget))
 535         * process_list->number_of_process ;
 536
 537   return 0;
 538 }
 539
 540 int processlist_remove( ProcessList *process_list,
 541       guint pid,
 542       guint cpu,
 543       LttTime *birth,
 544       guint trace_num)
 545 {
 546   ProcessInfo Process_Info;
 547   gint *path_indices;
 548   HashedProcessData *hashed_process_data;
 549   GtkTreeIter iter;
 550
 551   Process_Info.pid = pid;
 552   if(pid == 0)
 553     Process_Info.cpu = cpu;
 554   else
 555     Process_Info.cpu = 0;
 556   Process_Info.birth = *birth;
 557   Process_Info.trace_num = trace_num;
 558
 559
 560   if(hashed_process_data =
 561     (HashedProcessData*)g_hash_table_lookup(
 562           process_list->process_hash,
 563           &Process_Info))
 564   {
 565     iter = hashed_process_data->y_iter;
 566
 567     gtk_list_store_remove (process_list->list_store, &iter);
 568
 569     g_hash_table_remove(process_list->process_hash,
 570         &Process_Info);
 571
 572     process_list->number_of_process--;
 573
 574     return 0;
 575   } else {
 576     return 1;
 577   }
 578 }
 579
 580
 581 guint processlist_get_height(ProcessList *process_list)
 582 {
 583   return get_cell_height(process_list,
 584                          GTK_TREE_VIEW(process_list->process_list_widget))
 585         * process_list->number_of_process ;
 586 }
 587
 588
 589 __inline gint processlist_get_process_pixels(  ProcessList *process_list,
 590           guint pid, guint cpu, LttTime *birth, guint trace_num,
 591           guint *y,
 592           guint *height,
 593           HashedProcessData **pm_hashed_process_data)
 594 {
 595   ProcessInfo Process_Info;
 596   gint *path_indices;
 597   GtkTreePath *tree_path;
 598   HashedProcessData *hashed_process_data = NULL;
 599
 600   Process_Info.pid = pid;
 601   if(pid == 0)
 602     Process_Info.cpu = cpu;
 603   else
 604     Process_Info.cpu = 0;
 605   Process_Info.birth = *birth;
 606   Process_Info.trace_num = trace_num;
 607
 608   if(hashed_process_data =
 609     (HashedProcessData*)g_hash_table_lookup(
 610           process_list->process_hash,
 611           &Process_Info))
 612   {
 613     tree_path = gtk_tree_model_get_path(
 614                     GTK_TREE_MODEL(process_list->list_store),
 615                     &hashed_process_data->y_iter);
 616     path_indices =  gtk_tree_path_get_indices (tree_path);
 617
 618     *height = get_cell_height(process_list,
 619         GTK_TREE_VIEW(process_list->process_list_widget));
 620     *y = *height * path_indices[0];
 621     *pm_hashed_process_data = hashed_process_data;
 622     gtk_tree_path_free(tree_path);
 623
 624     return 0;
 625   } else {
 626     *pm_hashed_process_data = hashed_process_data;
 627     return 1;
 628   }
 629
 630 }
 631
 632
 633 __inline gint processlist_get_pixels_from_data(  ProcessList *process_list,
 634           ProcessInfo *process_info,
 635           HashedProcessData *hashed_process_data,
 636           guint *y,
 637           guint *height)
 638 {
 639   gint *path_indices;
 640   GtkTreePath *tree_path;
 641
 642   tree_path = gtk_tree_model_get_path(GTK_TREE_MODEL(process_list->list_store),
 643                     &hashed_process_data->y_iter);
 644   path_indices =  gtk_tree_path_get_indices (tree_path);
 645
 646   *height = get_cell_height(process_list,
 647       GTK_TREE_VIEW(process_list->process_list_widget));
 648   *y = *height * path_indices[0];
 649   gtk_tree_path_free(tree_path);
 650
 651   return 0;
 652
 653 }
 654
 655 static __inline guint get_cpu_number_from_name(GQuark name)
 656 {
 657   const gchar *string;
 658   char *begin;
 659   guint cpu;
 660
 661   string = g_quark_to_string(name);
 662
 663   begin = strrchr(string, '/');
 664   begin++;
 665
 666   g_assert(begin != '\0');
 667
 668   cpu = strtoul(begin, NULL, 10);
 669
 670   return cpu;
 671 }
 672