[lttv.git] / ltt / branches / poly / lttv / modules / gui / controlflow / processlist.c

/* This file is part of the Linux Trace Toolkit viewer
 * Copyright (C) 2003-2004 Mathieu Desnoyers
 *
 * This program is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License Version 2 as
 * published by the Free Software Foundation;
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, write to the Free Software
 * Foundation, Inc., 59 Temple Place - Suite 330, Boston, 
 * MA 02111-1307, USA.
 */

#include <gtk/gtk.h>
#include <glib.h>
#include <string.h>
#include <stdlib.h>

#include "processlist.h"
#include "drawitem.h"

#define g_info(format...) g_log (G_LOG_DOMAIN, G_LOG_LEVEL_INFO, format)
#define g_debug(format...) g_log (G_LOG_DOMAIN, G_LOG_LEVEL_DEBUG, format)


/*****************************************************************************
 *                       Methods to synchronize process list                 *
 *****************************************************************************/

static __inline__ guint get_cpu_number_from_name(GQuark name);
  
/* Enumeration of the columns */
enum
{
  PROCESS_COLUMN,
  PID_COLUMN,
  PPID_COLUMN,
  CPU_COLUMN,
  BIRTH_S_COLUMN,
  BIRTH_NS_COLUMN,
  TRACE_COLUMN,
  N_COLUMNS
};


gint process_sort_func  ( GtkTreeModel *model,
        GtkTreeIter *it_a,
        GtkTreeIter *it_b,
        gpointer user_data)
{
  GValue a, b;

  memset(&a, 0, sizeof(GValue));
  memset(&b, 0, sizeof(GValue));
  
  /* Order by PID */
  gtk_tree_model_get_value( model,
          it_a,
          PID_COLUMN,
          &a);

  gtk_tree_model_get_value( model,
          it_b,
          PID_COLUMN,
          &b);

  if(G_VALUE_TYPE(&a) == G_TYPE_UINT
    && G_VALUE_TYPE(&b) == G_TYPE_UINT )
  {
    {

      if(g_value_get_uint(&a) == 0 &&  g_value_get_uint(&b) == 0) {

        GValue cpua, cpub;

        memset(&cpua, 0, sizeof(GValue));
        memset(&cpub, 0, sizeof(GValue));
       
        /* If 0, order by CPU */
        gtk_tree_model_get_value( model,
                it_a,
                CPU_COLUMN,
                &cpua);

        gtk_tree_model_get_value( model,
                it_b,
                CPU_COLUMN,
                &cpub);

        if(G_VALUE_TYPE(&cpua) == G_TYPE_UINT
          && G_VALUE_TYPE(&cpub) == G_TYPE_UINT )
        {
          if(g_value_get_uint(&cpua) > g_value_get_uint(&cpub))
          {
            g_value_unset(&cpua);
            g_value_unset(&cpub);
            return 1;
          }
          if(g_value_get_uint(&cpua) < g_value_get_uint(&cpub))
          {
            g_value_unset(&cpua);
            g_value_unset(&cpub);
            return 0;
          }
        }

        g_value_unset(&cpua);
        g_value_unset(&cpub);

      } else { /* if not 0, order by pid */
      
        if(g_value_get_uint(&a) > g_value_get_uint(&b))
        {
          g_value_unset(&a);
          g_value_unset(&b);
          return 1;
        }
        if(g_value_get_uint(&a) < g_value_get_uint(&b))
        {
          g_value_unset(&a);
          g_value_unset(&b);
          return 0;
        }
      }
    }
  }

  g_value_unset(&a);
  g_value_unset(&b);


  /* Order by birth second */
  gtk_tree_model_get_value( model,
          it_a,
          BIRTH_S_COLUMN,
          &a);

  gtk_tree_model_get_value( model,
          it_b,
          BIRTH_S_COLUMN,
          &b);


  if(G_VALUE_TYPE(&a) == G_TYPE_ULONG
    && G_VALUE_TYPE(&b) == G_TYPE_ULONG )
  {
    if(g_value_get_ulong(&a) > g_value_get_ulong(&b))
    {
      g_value_unset(&a);
      g_value_unset(&b);
      return 1;
    }
    if(g_value_get_ulong(&a) < g_value_get_ulong(&b))
    {
      g_value_unset(&a);
      g_value_unset(&b);
      return 0;
    }

  }

  g_value_unset(&a);
  g_value_unset(&b);

  /* Order by birth nanosecond */
  gtk_tree_model_get_value( model,
          it_a,
          BIRTH_NS_COLUMN,
          &a);

  gtk_tree_model_get_value( model,
          it_b,
          BIRTH_NS_COLUMN,
          &b);


  if(G_VALUE_TYPE(&a) == G_TYPE_ULONG
    && G_VALUE_TYPE(&b) == G_TYPE_ULONG )
  {
    if(g_value_get_ulong(&a) > g_value_get_ulong(&b))
    {
      g_value_unset(&a);
      g_value_unset(&b);
      return 1;
    }
    if(g_value_get_ulong(&a) < g_value_get_ulong(&b))
    {
      g_value_unset(&a);
      g_value_unset(&b);
      return 0;
    }

  }
  
  g_value_unset(&a);
  g_value_unset(&b);

  /* Order by trace_num */
  gtk_tree_model_get_value( model,
          it_a,
          TRACE_COLUMN,
          &a);

  gtk_tree_model_get_value( model,
          it_b,
          TRACE_COLUMN,
          &b);

  if(G_VALUE_TYPE(&a) == G_TYPE_ULONG
    && G_VALUE_TYPE(&b) == G_TYPE_ULONG )
  {
    if(g_value_get_ulong(&a) > g_value_get_ulong(&b))
    {
      g_value_unset(&a);
      g_value_unset(&b);
      return 1;
    }
    if(g_value_get_ulong(&a) < g_value_get_ulong(&b))
    {
      g_value_unset(&a);
      g_value_unset(&b);
      return 0;
    }

  }

  return 0;

}

static guint process_list_hash_fct(gconstpointer key)
{
  guint pid = ((ProcessInfo*)key)->pid;
  return ((pid>>8 ^ pid>>4 ^ pid>>2 ^ pid) ^ ((ProcessInfo*)key)->cpu);
}

static gboolean process_list_equ_fct(gconstpointer a, gconstpointer b)
{
  const ProcessInfo *pa = (const ProcessInfo*)a;
  const ProcessInfo *pb = (const ProcessInfo*)b;
  
  if(pa->pid != pb->pid)
    return 0;

  if((pa->pid == 0 && (pa->cpu != pb->cpu)))
    return 0;

  if(pa->birth.tv_sec != pb->birth.tv_sec)
    return 0;

  if(pa->birth.tv_nsec != pb->birth.tv_nsec)
    return 0;

  if(pa->trace_num != pb->trace_num)
    return 0;

  return 1;
}

void destroy_hash_key(gpointer key);

void destroy_hash_data(gpointer data);


ProcessList *processlist_construct(void)
{
  GtkTreeViewColumn *column;
  GtkCellRenderer *renderer;
  
  ProcessList* process_list = g_new(ProcessList,1);
  
  process_list->number_of_process = 0;
  process_list->cell_height_cache = -1;

  process_list->current_process_info = NULL;
  process_list->current_hash_data = NULL;

  /* Create the Process list */
  process_list->list_store = gtk_list_store_new (  N_COLUMNS,
              G_TYPE_STRING,
              G_TYPE_UINT,
              G_TYPE_UINT,
              G_TYPE_UINT,
              G_TYPE_ULONG,
              G_TYPE_ULONG,
              G_TYPE_ULONG);


  process_list->process_list_widget = 
    gtk_tree_view_new_with_model
    (GTK_TREE_MODEL (process_list->list_store));
  g_object_unref (G_OBJECT (process_list->list_store));

  gtk_tree_sortable_set_sort_func(
      GTK_TREE_SORTABLE(process_list->list_store),
      PID_COLUMN,
      process_sort_func,
      NULL,
      NULL);
  
  gtk_tree_sortable_set_sort_column_id(
      GTK_TREE_SORTABLE(process_list->list_store),
      PID_COLUMN,
      GTK_SORT_ASCENDING);
  
  process_list->process_hash = g_hash_table_new_full(
      process_list_hash_fct, process_list_equ_fct,
      destroy_hash_key, destroy_hash_data
      );
  
  
  gtk_tree_view_set_headers_visible(
    GTK_TREE_VIEW(process_list->process_list_widget), TRUE);

  /* Create a column, associating the "text" attribute of the
   * cell_renderer to the first column of the model */
  /* Columns alignment : 0.0 : Left    0.5 : Center   1.0 : Right */
  renderer = gtk_cell_renderer_text_new ();
  column = gtk_tree_view_column_new_with_attributes ( "Process",
                renderer,
                "text",
                PROCESS_COLUMN,
                NULL);
  gtk_tree_view_column_set_alignment (column, 0.0);
  gtk_tree_view_column_set_fixed_width (column, 45);
  gtk_tree_view_append_column (
    GTK_TREE_VIEW (process_list->process_list_widget), column);
  
  process_list->button = column->button;
  
  column = gtk_tree_view_column_new_with_attributes ( "PID",
                renderer,
                "text",
                PID_COLUMN,
                NULL);
  gtk_tree_view_append_column (
    GTK_TREE_VIEW (process_list->process_list_widget), column);

  column = gtk_tree_view_column_new_with_attributes ( "PPID",
                renderer,
                "text",
                PPID_COLUMN,
                NULL);
  gtk_tree_view_append_column (
    GTK_TREE_VIEW (process_list->process_list_widget), column);
  
  column = gtk_tree_view_column_new_with_attributes ( "CPU",
                renderer,
                "text",
                CPU_COLUMN,
                NULL);
  gtk_tree_view_append_column (
    GTK_TREE_VIEW (process_list->process_list_widget), column);

  column = gtk_tree_view_column_new_with_attributes ( "Birth sec",
                renderer,
                "text",
                BIRTH_S_COLUMN,
                NULL);
  gtk_tree_view_append_column (
    GTK_TREE_VIEW (process_list->process_list_widget), column);

  //gtk_tree_view_column_set_visible(column, 0);
  //
  column = gtk_tree_view_column_new_with_attributes ( "Birth nsec",
                renderer,
                "text",
                BIRTH_NS_COLUMN,
                NULL);
  gtk_tree_view_append_column (
    GTK_TREE_VIEW (process_list->process_list_widget), column);

  column = gtk_tree_view_column_new_with_attributes ( "TRACE",
                renderer,
                "text",
                TRACE_COLUMN,
                NULL);
  gtk_tree_view_append_column (
    GTK_TREE_VIEW (process_list->process_list_widget), column);


  //gtk_tree_view_column_set_visible(column, 0);
  
  g_object_set_data_full(
      G_OBJECT(process_list->process_list_widget),
      "process_list_Data",
      process_list,
      (GDestroyNotify)processlist_destroy);

  return process_list;
}

void processlist_destroy(ProcessList *process_list)
{
  g_debug("processlist_destroy %p", process_list);
  g_hash_table_destroy(process_list->process_hash);
  process_list->process_hash = NULL;

  g_free(process_list);
  g_debug("processlist_destroy end");
}

static gboolean remove_hash_item(ProcessInfo *process_info,
                                 HashedProcessData *hashed_process_data,
                                 ProcessList *process_list)
{
  GtkTreeIter iter;

  iter = hashed_process_data->y_iter;

  gtk_list_store_remove (process_list->list_store, &iter);

  if(process_info == process_list->current_process_info)
    process_list->current_process_info = NULL;
  if(hashed_process_data == process_list->current_hash_data)
    process_list->current_hash_data = NULL;

  return TRUE; /* remove the element from the hash table */
}

void processlist_clear(ProcessList *process_list)
{
  g_info("processlist_clear %p", process_list);

  g_hash_table_foreach_remove(process_list->process_hash,
                              (GHRFunc)remove_hash_item,
                              (gpointer)process_list);
  process_list->number_of_process = 0;
}


GtkWidget *processlist_get_widget(ProcessList *process_list)
{
  return process_list->process_list_widget;
}


static __inline__ gint get_cell_height(ProcessList *process_list, GtkTreeView *tree_view)
{
  gint height = process_list->cell_height_cache;
  if(height != -1) return height;
  else {
    GtkTreeViewColumn *Column = gtk_tree_view_get_column(tree_view, 0);
  
    gtk_tree_view_column_cell_get_size(Column, NULL, NULL, NULL, NULL,
                                       &process_list->cell_height_cache);
  }
    
  
  return process_list->cell_height_cache;
}

void destroy_hash_key(gpointer key)
{
  g_free(key);
}

void destroy_hash_data(gpointer data)
{
  g_free(data);
}

int processlist_add(  ProcessList *process_list,
      guint pid,
      guint cpu,
      guint ppid,
      LttTime *birth,
      guint trace_num,
      const gchar *name,
      guint *height,
      ProcessInfo **pm_process_info,
      HashedProcessData **pm_hashed_process_data)
{
  ProcessInfo *Process_Info = g_new(ProcessInfo, 1);
  HashedProcessData *hashed_process_data = g_new(HashedProcessData, 1);
  *pm_hashed_process_data = hashed_process_data;
  *pm_process_info = Process_Info;
  
  Process_Info->pid = pid;
  if(pid == 0)
    Process_Info->cpu = cpu;
  else
    Process_Info->cpu = 0;
  Process_Info->ppid = ppid;
  Process_Info->birth = *birth;
  Process_Info->trace_num = trace_num;

  /* When we create it from before state update, we are sure that the
   * last event occured before the beginning of the global area.
   *
   * If it is created after state update, this value (0) will be
   * overriden by the new state before anything is drawn.
   */
  hashed_process_data->x.over = 0;
  hashed_process_data->x.over_used = FALSE;
  hashed_process_data->x.over_marked = FALSE;
  hashed_process_data->x.middle = 0;
  hashed_process_data->x.middle_used = FALSE;
  hashed_process_data->x.middle_marked = FALSE;
  hashed_process_data->x.under = 0;
  hashed_process_data->x.under_used = FALSE;
  hashed_process_data->x.under_marked = FALSE;
  hashed_process_data->next_good_time = ltt_time_zero;
  
  /* Add a new row to the model */
  gtk_list_store_append ( process_list->list_store,
                          &hashed_process_data->y_iter);

  gtk_list_store_set (  process_list->list_store, &hashed_process_data->y_iter,
        PROCESS_COLUMN, name,
        PID_COLUMN, pid,
        PPID_COLUMN, ppid,
        CPU_COLUMN, get_cpu_number_from_name(cpu),
        BIRTH_S_COLUMN, birth->tv_sec,
        BIRTH_NS_COLUMN, birth->tv_nsec,
        TRACE_COLUMN, trace_num,
        -1);
#if 0
  hashed_process_data->row_ref = gtk_tree_row_reference_new (
      GTK_TREE_MODEL(process_list->list_store),
      gtk_tree_model_get_path(
        GTK_TREE_MODEL(process_list->list_store),
        &iter));
#endif //0
  g_hash_table_insert(process_list->process_hash,
        (gpointer)Process_Info,
        (gpointer)hashed_process_data);
  
  //g_critical ( "iter after : %s", gtk_tree_path_to_string (
  //    gtk_tree_model_get_path (
  //        GTK_TREE_MODEL(process_list->list_store),
  //        &iter)));
  process_list->number_of_process++;

  *height = get_cell_height(process_list,
                            GTK_TREE_VIEW(process_list->process_list_widget))
        * process_list->number_of_process ;
  
  return 0;
}

int processlist_remove( ProcessList *process_list,
      guint pid,
      guint cpu,
      LttTime *birth,
      guint trace_num)
{
  ProcessInfo process_info;
  gint *path_indices;
  HashedProcessData *hashed_process_data;
  GtkTreeIter iter;
  
  process_info.pid = pid;
  if(pid == 0)
    process_info.cpu = cpu;
  else
    process_info.cpu = 0;
  process_info.birth = *birth;
  process_info.trace_num = trace_num;


  if(hashed_process_data = 
    (HashedProcessData*)g_hash_table_lookup(
          process_list->process_hash,
          &process_info))
  {
    iter = hashed_process_data->y_iter;

    gtk_list_store_remove (process_list->list_store, &iter);
    
    g_hash_table_remove(process_list->process_hash,
        &process_info);

    if(hashed_process_data == process_list->current_hash_data) {
      process_list->current_process_info = NULL;
      process_list->current_hash_data = NULL;
    }

    process_list->number_of_process--;

    return 0; 
  } else {
    return 1;
  }
}


__inline__ guint processlist_get_height(ProcessList *process_list)
{
  return get_cell_height(process_list,
                         (GtkTreeView*)process_list->process_list_widget)
        * process_list->number_of_process ;
}


__inline__ gint processlist_get_process_pixels(  ProcessList *process_list,
          guint pid, guint cpu, LttTime *birth, guint trace_num,
          guint *y,
          guint *height,
          HashedProcessData **pm_hashed_process_data)
{
  ProcessInfo process_info;
  gint *path_indices;
  GtkTreePath *tree_path;
  HashedProcessData *hashed_process_data = NULL;

  process_info.pid = pid;
  if(pid == 0)
    process_info.cpu = cpu;
  else
    process_info.cpu = 0;
  process_info.birth = *birth;
  process_info.trace_num = trace_num;

  if(hashed_process_data = 
    (HashedProcessData*)g_hash_table_lookup(
          process_list->process_hash,
          &process_info))
  {
    tree_path = gtk_tree_model_get_path(
                    (GtkTreeModel*)process_list->list_store,
                    &hashed_process_data->y_iter);
    path_indices =  gtk_tree_path_get_indices (tree_path);

    *height = get_cell_height(process_list,
        (GtkTreeView*)process_list->process_list_widget);
    *y = *height * path_indices[0];
    *pm_hashed_process_data = hashed_process_data;
    gtk_tree_path_free(tree_path);
    
    return 0; 
  } else {
    *pm_hashed_process_data = hashed_process_data;
    return 1;
  }

}


__inline__ gint processlist_get_pixels_from_data(  ProcessList *process_list,
          ProcessInfo *process_info,
          HashedProcessData *hashed_process_data,
          guint *y,
          guint *height)
{
  gint *path_indices;
  GtkTreePath *tree_path;

  tree_path = gtk_tree_model_get_path((GtkTreeModel*)process_list->list_store,
                    &hashed_process_data->y_iter);
  path_indices =  gtk_tree_path_get_indices (tree_path);

  *height = get_cell_height(process_list,
      (GtkTreeView*)process_list->process_list_widget);
  *y = *height * path_indices[0];
  gtk_tree_path_free(tree_path);

  return 0; 

}

static __inline__ guint get_cpu_number_from_name(GQuark name)
{
  const gchar *string;
  char *begin;
  guint cpu;

  string = g_quark_to_string(name);

  begin = strrchr(string, '/');
  begin++;

  g_assert(begin != '\0');

  cpu = strtoul(begin, NULL, 10);

  return cpu;
}
Commit	Line	Data
ce0214a6	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	*/
f0d936c0	18
fa2c4dbe	19	#include <gtk/gtk.h>
fa2c4dbe	20	#include <glib.h>
a95bc95a	21	#include <string.h>
a95bc95a	22	#include <stdlib.h>
d66666fe	23
	24	#include "processlist.h"
	25	#include "drawitem.h"
fa2c4dbe	26
ca0f8a8e	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
f0d936c0	31	/*****************************************************************************
	32	* Methods to synchronize process list *
	33	*****************************************************************************/
	34
31b6868d	35	static __inline__ guint get_cpu_number_from_name(GQuark name);
a95bc95a	36
f0d936c0	37	/* Enumeration of the columns */
	38	enum
	39	{
a56a1ba4	40	PROCESS_COLUMN,
a56a1ba4	41	PID_COLUMN,
e92eabaf	42	PPID_COLUMN,
a95bc95a	43	CPU_COLUMN,
a56a1ba4	44	BIRTH_S_COLUMN,
a56a1ba4	45	BIRTH_NS_COLUMN,
d0cd7f09	46	TRACE_COLUMN,
a56a1ba4	47	N_COLUMNS
f0d936c0	48	};
	49
	50
a56a1ba4	51	gint process_sort_func ( GtkTreeModel *model,
	52	GtkTreeIter *it_a,
	53	GtkTreeIter *it_b,
	54	gpointer user_data)
fa2c4dbe	55	{
a56a1ba4	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	{
a56a1ba4	75	{
a95bc95a	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	}
a56a1ba4	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	}
a95bc95a	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	}
a56a1ba4	197
	198	}
	199
	200	g_value_unset(&a);
	201	g_value_unset(&b);
	202
d0cd7f09	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
a56a1ba4	232	return 0;
fa2c4dbe	233
	234	}
	235
7893f726	236	static guint process_list_hash_fct(gconstpointer key)
fa2c4dbe	237	{
7893f726	238	guint pid = ((ProcessInfo*)key)->pid;
7893f726	239	return ((pid>>8 ^ pid>>4 ^ pid>>2 ^ pid) ^ ((ProcessInfo*)key)->cpu);
fa2c4dbe	240	}
fa2c4dbe	241
7893f726	242	static gboolean process_list_equ_fct(gconstpointer a, gconstpointer b)
fa2c4dbe	243	{
a95bc95a	244	const ProcessInfo pa = (const ProcessInfo)a;
a95bc95a	245	const ProcessInfo pb = (const ProcessInfo)b;
7893f726	246
a95bc95a	247	if(pa->pid != pb->pid)
a56a1ba4	248	return 0;
a95bc95a	249
a95bc95a	250	if((pa->pid == 0 && (pa->cpu != pb->cpu)))
a56a1ba4	251	return 0;
a56a1ba4	252
a95bc95a	253	if(pa->birth.tv_sec != pb->birth.tv_sec)
a56a1ba4	254	return 0;
a56a1ba4	255
a95bc95a	256	if(pa->birth.tv_nsec != pb->birth.tv_nsec)
	257	return 0;
	258
	259	if(pa->trace_num != pb->trace_num)
d0cd7f09	260	return 0;
d0cd7f09	261
a56a1ba4	262	return 1;
fa2c4dbe	263	}
fa2c4dbe	264
4c69e0cc	265	void destroy_hash_key(gpointer key);
fa2c4dbe	266
4c69e0cc	267	void destroy_hash_data(gpointer data);
fa2c4dbe	268
	269
	270
	271
4c69e0cc	272	ProcessList *processlist_construct(void)
f0d936c0	273	{
a56a1ba4	274	GtkTreeViewColumn *column;
	275	GtkCellRenderer *renderer;
	276
ba90bc77	277	ProcessList* process_list = g_new(ProcessList,1);
a56a1ba4	278
ba90bc77	279	process_list->number_of_process = 0;
ad96f4a0	280	process_list->cell_height_cache = -1;
a56a1ba4	281
4e86ae2e	282	process_list->current_process_info = NULL;
	283	process_list->current_hash_data = NULL;
	284
a56a1ba4	285	/* Create the Process list */
f5d980bf	286	process_list->list_store = gtk_list_store_new ( N_COLUMNS,
a56a1ba4	287	G_TYPE_STRING,
a56a1ba4	288	G_TYPE_UINT,
e92eabaf	289	G_TYPE_UINT,
a95bc95a	290	G_TYPE_UINT,
a56a1ba4	291	G_TYPE_ULONG,
d0cd7f09	292	G_TYPE_ULONG,
a56a1ba4	293	G_TYPE_ULONG);
	294
	295
f5d980bf	296	process_list->process_list_widget =
a56a1ba4	297	gtk_tree_view_new_with_model
f5d980bf	298	(GTK_TREE_MODEL (process_list->list_store));
f5d980bf	299	g_object_unref (G_OBJECT (process_list->list_store));
a56a1ba4	300
a56a1ba4	301	gtk_tree_sortable_set_sort_func(
f5d980bf	302	GTK_TREE_SORTABLE(process_list->list_store),
a56a1ba4	303	PID_COLUMN,
	304	process_sort_func,
	305	NULL,
	306	NULL);
	307
	308	gtk_tree_sortable_set_sort_column_id(
f5d980bf	309	GTK_TREE_SORTABLE(process_list->list_store),
a56a1ba4	310	PID_COLUMN,
	311	GTK_SORT_ASCENDING);
	312
14963be0	313	process_list->process_hash = g_hash_table_new_full(
7893f726	314	process_list_hash_fct, process_list_equ_fct,
a56a1ba4	315	destroy_hash_key, destroy_hash_data
	316	);
	317
	318
	319	gtk_tree_view_set_headers_visible(
3cb8b205	320	GTK_TREE_VIEW(process_list->process_list_widget), TRUE);
a56a1ba4	321
	322	/* Create a column, associating the "text" attribute of the
	323	* cell_renderer to the first column of the model */
	324	/* Columns alignment : 0.0 : Left 0.5 : Center 1.0 : Right */
	325	renderer = gtk_cell_renderer_text_new ();
	326	column = gtk_tree_view_column_new_with_attributes ( "Process",
	327	renderer,
	328	"text",
	329	PROCESS_COLUMN,
	330	NULL);
	331	gtk_tree_view_column_set_alignment (column, 0.0);
	332	gtk_tree_view_column_set_fixed_width (column, 45);
	333	gtk_tree_view_append_column (
f5d980bf	334	GTK_TREE_VIEW (process_list->process_list_widget), column);
b9a010a2	335
	336	process_list->button = column->button;
	337
a56a1ba4	338	column = gtk_tree_view_column_new_with_attributes ( "PID",
	339	renderer,
	340	"text",
	341	PID_COLUMN,
	342	NULL);
	343	gtk_tree_view_append_column (
f5d980bf	344	GTK_TREE_VIEW (process_list->process_list_widget), column);
a56a1ba4	345
e92eabaf	346	column = gtk_tree_view_column_new_with_attributes ( "PPID",
	347	renderer,
	348	"text",
	349	PPID_COLUMN,
	350	NULL);
	351	gtk_tree_view_append_column (
	352	GTK_TREE_VIEW (process_list->process_list_widget), column);
a95bc95a	353
	354	column = gtk_tree_view_column_new_with_attributes ( "CPU",
	355	renderer,
	356	"text",
	357	CPU_COLUMN,
	358	NULL);
	359	gtk_tree_view_append_column (
	360	GTK_TREE_VIEW (process_list->process_list_widget), column);
a56a1ba4	361
	362	column = gtk_tree_view_column_new_with_attributes ( "Birth sec",
	363	renderer,
	364	"text",
	365	BIRTH_S_COLUMN,
	366	NULL);
	367	gtk_tree_view_append_column (
f5d980bf	368	GTK_TREE_VIEW (process_list->process_list_widget), column);
a56a1ba4	369
	370	//gtk_tree_view_column_set_visible(column, 0);
	371	//
	372	column = gtk_tree_view_column_new_with_attributes ( "Birth nsec",
	373	renderer,
	374	"text",
	375	BIRTH_NS_COLUMN,
	376	NULL);
	377	gtk_tree_view_append_column (
f5d980bf	378	GTK_TREE_VIEW (process_list->process_list_widget), column);
a56a1ba4	379
d0cd7f09	380	column = gtk_tree_view_column_new_with_attributes ( "TRACE",
	381	renderer,
	382	"text",
	383	TRACE_COLUMN,
	384	NULL);
	385	gtk_tree_view_append_column (
	386	GTK_TREE_VIEW (process_list->process_list_widget), column);
	387
	388
a56a1ba4	389	//gtk_tree_view_column_set_visible(column, 0);
	390
	391	g_object_set_data_full(
f5d980bf	392	G_OBJECT(process_list->process_list_widget),
ba90bc77	393	"process_list_Data",
ba90bc77	394	process_list,
a56a1ba4	395	(GDestroyNotify)processlist_destroy);
a56a1ba4	396
ba90bc77	397	return process_list;
f0d936c0	398	}
b9a010a2	399
ba90bc77	400	void processlist_destroy(ProcessList *process_list)
f0d936c0	401	{
b9a010a2	402	g_debug("processlist_destroy %p", process_list);
14963be0	403	g_hash_table_destroy(process_list->process_hash);
14963be0	404	process_list->process_hash = NULL;
f0d936c0	405
ba90bc77	406	g_free(process_list);
b9a010a2	407	g_debug("processlist_destroy end");
	408	}
	409
	410	static gboolean remove_hash_item(ProcessInfo *process_info,
	411	HashedProcessData *hashed_process_data,
	412	ProcessList *process_list)
	413	{
b9a010a2	414	GtkTreeIter iter;
b9a010a2	415
ad96f4a0	416	iter = hashed_process_data->y_iter;
b9a010a2	417
	418	gtk_list_store_remove (process_list->list_store, &iter);
	419
4e86ae2e	420	if(process_info == process_list->current_process_info)
	421	process_list->current_process_info = NULL;
	422	if(hashed_process_data == process_list->current_hash_data)
	423	process_list->current_hash_data = NULL;
	424
b9a010a2	425	return TRUE; /* remove the element from the hash table */
f0d936c0	426	}
f0d936c0	427
b9a010a2	428	void processlist_clear(ProcessList *process_list)
	429	{
	430	g_info("processlist_clear %p", process_list);
	431
	432	g_hash_table_foreach_remove(process_list->process_hash,
	433	(GHRFunc)remove_hash_item,
	434	(gpointer)process_list);
	435	process_list->number_of_process = 0;
	436	}
	437
	438
ba90bc77	439	GtkWidget processlist_get_widget(ProcessList process_list)
f0d936c0	440	{
f5d980bf	441	return process_list->process_list_widget;
f0d936c0	442	}
	443
	444
	445
31b6868d	446	static __inline__ gint get_cell_height(ProcessList process_list, GtkTreeView tree_view)
f0d936c0	447	{
ad96f4a0	448	gint height = process_list->cell_height_cache;
	449	if(height != -1) return height;
	450	else {
	451	GtkTreeViewColumn *Column = gtk_tree_view_get_column(tree_view, 0);
a56a1ba4	452
ad96f4a0	453	gtk_tree_view_column_cell_get_size(Column, NULL, NULL, NULL, NULL,
	454	&process_list->cell_height_cache);
	455	}
	456
a56a1ba4	457
ad96f4a0	458	return process_list->cell_height_cache;
f0d936c0	459	}
f0d936c0	460
4c69e0cc	461	void destroy_hash_key(gpointer key)
f0d936c0	462	{
a56a1ba4	463	g_free(key);
fa2c4dbe	464	}
fa2c4dbe	465
4c69e0cc	466	void destroy_hash_data(gpointer data)
fa2c4dbe	467	{
a56a1ba4	468	g_free(data);
fa2c4dbe	469	}
fa2c4dbe	470
ba90bc77	471	int processlist_add( ProcessList *process_list,
a56a1ba4	472	guint pid,
a95bc95a	473	guint cpu,
e92eabaf	474	guint ppid,
a56a1ba4	475	LttTime *birth,
d0cd7f09	476	guint trace_num,
51705146	477	const gchar *name,
a56a1ba4	478	guint *height,
4e86ae2e	479	ProcessInfo **pm_process_info,
f5d980bf	480	HashedProcessData **pm_hashed_process_data)
fa2c4dbe	481	{
a56a1ba4	482	ProcessInfo *Process_Info = g_new(ProcessInfo, 1);
14963be0	483	HashedProcessData *hashed_process_data = g_new(HashedProcessData, 1);
f5d980bf	484	*pm_hashed_process_data = hashed_process_data;
4e86ae2e	485	*pm_process_info = Process_Info;
a56a1ba4	486
a56a1ba4	487	Process_Info->pid = pid;
a95bc95a	488	if(pid == 0)
	489	Process_Info->cpu = cpu;
	490	else
	491	Process_Info->cpu = 0;
e92eabaf	492	Process_Info->ppid = ppid;
a56a1ba4	493	Process_Info->birth = *birth;
d0cd7f09	494	Process_Info->trace_num = trace_num;
b9a010a2	495
	496	/* When we create it from before state update, we are sure that the
	497	* last event occured before the beginning of the global area.
	498	*
	499	* If it is created after state update, this value (0) will be
	500	* overriden by the new state before anything is drawn.
	501	*/
23093869	502	hashed_process_data->x.over = 0;
e72908ed	503	hashed_process_data->x.over_used = FALSE;
b2743953	504	hashed_process_data->x.over_marked = FALSE;
23093869	505	hashed_process_data->x.middle = 0;
e72908ed	506	hashed_process_data->x.middle_used = FALSE;
b2743953	507	hashed_process_data->x.middle_marked = FALSE;
23093869	508	hashed_process_data->x.under = 0;
e72908ed	509	hashed_process_data->x.under_used = FALSE;
b2743953	510	hashed_process_data->x.under_marked = FALSE;
b2743953	511	hashed_process_data->next_good_time = ltt_time_zero;
a56a1ba4	512
a56a1ba4	513	/* Add a new row to the model */
ad96f4a0	514	gtk_list_store_append ( process_list->list_store,
	515	&hashed_process_data->y_iter);
	516
	517	gtk_list_store_set ( process_list->list_store, &hashed_process_data->y_iter,
a56a1ba4	518	PROCESS_COLUMN, name,
a56a1ba4	519	PID_COLUMN, pid,
e92eabaf	520	PPID_COLUMN, ppid,
a95bc95a	521	CPU_COLUMN, get_cpu_number_from_name(cpu),
a56a1ba4	522	BIRTH_S_COLUMN, birth->tv_sec,
a56a1ba4	523	BIRTH_NS_COLUMN, birth->tv_nsec,
d0cd7f09	524	TRACE_COLUMN, trace_num,
a56a1ba4	525	-1);
ad96f4a0	526	#if 0
f5d980bf	527	hashed_process_data->row_ref = gtk_tree_row_reference_new (
f5d980bf	528	GTK_TREE_MODEL(process_list->list_store),
a56a1ba4	529	gtk_tree_model_get_path(
f5d980bf	530	GTK_TREE_MODEL(process_list->list_store),
a56a1ba4	531	&iter));
ad96f4a0	532	#endif //0
a95bc95a	533	g_hash_table_insert(process_list->process_hash,
a56a1ba4	534	(gpointer)Process_Info,
14963be0	535	(gpointer)hashed_process_data);
a56a1ba4	536
	537	//g_critical ( "iter after : %s", gtk_tree_path_to_string (
	538	// gtk_tree_model_get_path (
f5d980bf	539	// GTK_TREE_MODEL(process_list->list_store),
a56a1ba4	540	// &iter)));
ba90bc77	541	process_list->number_of_process++;
a56a1ba4	542
ad96f4a0	543	*height = get_cell_height(process_list,
ad96f4a0	544	GTK_TREE_VIEW(process_list->process_list_widget))
ba90bc77	545	* process_list->number_of_process ;
a56a1ba4	546
a56a1ba4	547	return 0;
f0d936c0	548	}
f0d936c0	549
ba90bc77	550	int processlist_remove( ProcessList *process_list,
a56a1ba4	551	guint pid,
a95bc95a	552	guint cpu,
d0cd7f09	553	LttTime *birth,
d0cd7f09	554	guint trace_num)
f0d936c0	555	{
4e86ae2e	556	ProcessInfo process_info;
a56a1ba4	557	gint *path_indices;
14963be0	558	HashedProcessData *hashed_process_data;
a56a1ba4	559	GtkTreeIter iter;
a56a1ba4	560
4e86ae2e	561	process_info.pid = pid;
324cdea4	562	if(pid == 0)
4e86ae2e	563	process_info.cpu = cpu;
324cdea4	564	else
4e86ae2e	565	process_info.cpu = 0;
	566	process_info.birth = *birth;
	567	process_info.trace_num = trace_num;
a56a1ba4	568
a56a1ba4	569
14963be0	570	if(hashed_process_data =
a56a1ba4	571	(HashedProcessData*)g_hash_table_lookup(
14963be0	572	process_list->process_hash,
4e86ae2e	573	&process_info))
a56a1ba4	574	{
ad96f4a0	575	iter = hashed_process_data->y_iter;
a56a1ba4	576
f5d980bf	577	gtk_list_store_remove (process_list->list_store, &iter);
e800cf84	578
14963be0	579	g_hash_table_remove(process_list->process_hash,
4e86ae2e	580	&process_info);
	581
	582	if(hashed_process_data == process_list->current_hash_data) {
	583	process_list->current_process_info = NULL;
	584	process_list->current_hash_data = NULL;
	585	}
	586
ba90bc77	587	process_list->number_of_process--;
a56a1ba4	588
	589	return 0;
	590	} else {
	591	return 1;
	592	}
fa2c4dbe	593	}
	594
	595
31b6868d	596	__inline__ guint processlist_get_height(ProcessList *process_list)
fa2c4dbe	597	{
ad96f4a0	598	return get_cell_height(process_list,
898bd012	599	(GtkTreeView*)process_list->process_list_widget)
ba90bc77	600	* process_list->number_of_process ;
f0d936c0	601	}
fa2c4dbe	602
fa2c4dbe	603
31b6868d	604	__inline__ gint processlist_get_process_pixels( ProcessList *process_list,
a95bc95a	605	guint pid, guint cpu, LttTime *birth, guint trace_num,
a56a1ba4	606	guint *y,
a56a1ba4	607	guint *height,
f5d980bf	608	HashedProcessData **pm_hashed_process_data)
fa2c4dbe	609	{
4e86ae2e	610	ProcessInfo process_info;
a56a1ba4	611	gint *path_indices;
a56a1ba4	612	GtkTreePath *tree_path;
14963be0	613	HashedProcessData *hashed_process_data = NULL;
a56a1ba4	614
4e86ae2e	615	process_info.pid = pid;
324cdea4	616	if(pid == 0)
4e86ae2e	617	process_info.cpu = cpu;
324cdea4	618	else
4e86ae2e	619	process_info.cpu = 0;
	620	process_info.birth = *birth;
	621	process_info.trace_num = trace_num;
a56a1ba4	622
14963be0	623	if(hashed_process_data =
a56a1ba4	624	(HashedProcessData*)g_hash_table_lookup(
14963be0	625	process_list->process_hash,
4e86ae2e	626	&process_info))
a56a1ba4	627	{
ad96f4a0	628	tree_path = gtk_tree_model_get_path(
898bd012	629	(GtkTreeModel*)process_list->list_store,
ad96f4a0	630	&hashed_process_data->y_iter);
a56a1ba4	631	path_indices = gtk_tree_path_get_indices (tree_path);
a56a1ba4	632
ad96f4a0	633	*height = get_cell_height(process_list,
898bd012	634	(GtkTreeView*)process_list->process_list_widget);
a56a1ba4	635	y = height * path_indices[0];
f5d980bf	636	*pm_hashed_process_data = hashed_process_data;
51705146	637	gtk_tree_path_free(tree_path);
51705146	638
a56a1ba4	639	return 0;
a56a1ba4	640	} else {
f5d980bf	641	*pm_hashed_process_data = hashed_process_data;
a56a1ba4	642	return 1;
a56a1ba4	643	}
fa2c4dbe	644
fa2c4dbe	645	}
8b90e648	646
8b90e648	647
31b6868d	648	__inline__ gint processlist_get_pixels_from_data( ProcessList *process_list,
a56a1ba4	649	ProcessInfo *process_info,
14963be0	650	HashedProcessData *hashed_process_data,
a56a1ba4	651	guint *y,
a56a1ba4	652	guint *height)
8b90e648	653	{
a56a1ba4	654	gint *path_indices;
a56a1ba4	655	GtkTreePath *tree_path;
8b90e648	656
898bd012	657	tree_path = gtk_tree_model_get_path((GtkTreeModel*)process_list->list_store,
ad96f4a0	658	&hashed_process_data->y_iter);
a56a1ba4	659	path_indices = gtk_tree_path_get_indices (tree_path);
8b90e648	660
ad96f4a0	661	*height = get_cell_height(process_list,
898bd012	662	(GtkTreeView*)process_list->process_list_widget);
a56a1ba4	663	y = height * path_indices[0];
51705146	664	gtk_tree_path_free(tree_path);
8b90e648	665
a56a1ba4	666	return 0;
8b90e648	667
8b90e648	668	}
a95bc95a	669
31b6868d	670	static __inline__ guint get_cpu_number_from_name(GQuark name)
a95bc95a	671	{
a95bc95a	672	const gchar *string;
	673	char *begin;
	674	guint cpu;
	675
	676	string = g_quark_to_string(name);
	677
	678	begin = strrchr(string, '/');
	679	begin++;
	680
	681	g_assert(begin != '\0');
	682
	683	cpu = strtoul(begin, NULL, 10);
	684
	685	return cpu;
	686	}
	687