1 /* This file is part of the Linux Trace Toolkit viewer
2 * Copyright (C) 2003-2004 Mathieu Desnoyers
4 * This program is free software; you can redistribute it and/or modify
5 * it under the terms of the GNU General Public License Version 2 as
6 * published by the Free Software Foundation;
8 * This program is distributed in the hope that it will be useful,
9 * but WITHOUT ANY WARRANTY; without even the implied warranty of
10 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
11 * GNU General Public License for more details.
13 * You should have received a copy of the GNU General Public License
14 * along with this program; if not, write to the Free Software
15 * Foundation, Inc., 59 Temple Place - Suite 330, Boston,
30 #include "processlist.h"
34 #define g_info(format...) g_log (G_LOG_DOMAIN, G_LOG_LEVEL_INFO, format)
36 /* Preallocated Size of the index_to_pixmap array */
37 #define ALLOCATE_PROCESSES 1000
39 /*****************************************************************************
40 * Methods to synchronize process list *
41 *****************************************************************************/
44 gint
process_sort_func ( GtkTreeModel
*model
,
51 guint a_pid
, a_tgid
, a_ppid
, a_cpu
;
52 gulong a_birth_s
, a_birth_ns
;
57 guint b_pid
, b_tgid
, b_ppid
, b_cpu
;
58 gulong b_birth_s
, b_birth_ns
;
61 gtk_tree_model_get(model
,
63 PROCESS_COLUMN
, &a_name
,
64 BRAND_COLUMN
, &a_brand
,
69 BIRTH_S_COLUMN
, &a_birth_s
,
70 BIRTH_NS_COLUMN
, &a_birth_ns
,
71 TRACE_COLUMN
, &a_trace
,
74 gtk_tree_model_get(model
,
76 PROCESS_COLUMN
, &b_name
,
77 BRAND_COLUMN
, &b_brand
,
82 BIRTH_S_COLUMN
, &b_birth_s
,
83 BIRTH_NS_COLUMN
, &b_birth_ns
,
84 TRACE_COLUMN
, &b_trace
,
89 if(a_pid
== 0 && b_pid
== 0) {
90 /* If 0, order by CPU */
91 if(a_cpu
> b_cpu
) return 1;
92 if(a_cpu
< b_cpu
) return -1;
94 } else { /* if not 0, order by pid */
96 if(a_pid
> b_pid
) return 1;
97 if(a_pid
< b_pid
) return -1;
100 /* Order by birth second */
102 if(a_birth_s
> b_birth_s
) return 1;
103 if(a_birth_s
< b_birth_s
) return -1;
106 /* Order by birth nanosecond */
107 if(a_birth_ns
> b_birth_ns
) return 1;
108 if(a_birth_ns
< b_birth_ns
) return -1;
110 /* Order by trace_num */
111 if(a_trace
> b_trace
) return 1;
112 if(a_trace
< b_trace
) return -1;
118 static guint
process_list_hash_fct(gconstpointer key
)
120 guint pid
= ((const ProcessInfo
*)key
)->pid
;
121 return ((pid
>>8 ^ pid
>>4 ^ pid
>>2 ^ pid
) ^ ((const ProcessInfo
*)key
)->cpu
);
124 /* If hash is good, should be different */
125 static gboolean
process_list_equ_fct(gconstpointer a
, gconstpointer b
)
127 const ProcessInfo
*pa
= (const ProcessInfo
*)a
;
128 const ProcessInfo
*pb
= (const ProcessInfo
*)b
;
132 if(likely(pa
->pid
!= pb
->pid
))
134 if(likely((pa
->pid
== 0 && (pa
->cpu
!= pb
->cpu
))))
136 //TODO ybrosseau 2012-09-18 Check if we want to reenable birth comparision
137 // We currently do not have valid birth info, so don't compare it
138 /* if(unlikely(ltt_time_compare(pa->birth, pb->birth) != 0))
140 if(unlikely(pa
->trace_num
!= pb
->trace_num
))
146 void destroy_hash_key(gpointer key
);
148 void destroy_hash_data(gpointer data
);
151 gboolean
scroll_event(GtkWidget
*widget
, GdkEventScroll
*event
, gpointer data
)
153 ControlFlowData
*control_flow_data
=
154 (ControlFlowData
*)g_object_get_data(
156 "control_flow_data");
157 unsigned int cell_height
=
158 get_cell_height(GTK_TREE_VIEW(control_flow_data
->process_list
->process_list_widget
));
160 switch(event
->direction
) {
162 gtk_adjustment_set_value(control_flow_data
->v_adjust
,
163 gtk_adjustment_get_value(control_flow_data
->v_adjust
) - cell_height
);
165 case GDK_SCROLL_DOWN
:
166 gtk_adjustment_set_value(control_flow_data
->v_adjust
,
167 gtk_adjustment_get_value(control_flow_data
->v_adjust
) + cell_height
);
170 g_error("should only scroll up and down.");
176 static void update_index_to_pixmap_each(ProcessInfo
*key
,
177 HashedProcessData
*value
,
178 ProcessList
*process_list
)
180 guint array_index
= processlist_get_index_from_data(process_list
, value
);
182 g_assert(array_index
< process_list
->index_to_pixmap
->len
);
185 (GdkPixmap
**)&g_ptr_array_index(process_list
->index_to_pixmap
, array_index
);
187 *pixmap
= value
->pixmap
;
191 void update_index_to_pixmap(ProcessList
*process_list
)
193 g_ptr_array_set_size(process_list
->index_to_pixmap
,
194 g_hash_table_size(process_list
->process_hash
));
195 g_hash_table_foreach(process_list
->process_hash
,
196 (GHFunc
)update_index_to_pixmap_each
,
201 static void update_pixmap_size_each(ProcessInfo
*key
,
202 HashedProcessData
*value
,
205 GdkPixmap
*old_pixmap
= value
->pixmap
;
208 gdk_pixmap_new(old_pixmap
,
213 gdk_pixmap_unref(old_pixmap
);
217 void update_pixmap_size(ProcessList
*process_list
, guint width
)
219 g_hash_table_foreach(process_list
->process_hash
,
220 (GHFunc
)update_pixmap_size_each
,
221 GUINT_TO_POINTER(width
));
225 typedef struct _CopyPixmap
{
229 gint xsrc
, ysrc
, xdest
, ydest
, width
, height
;
232 static void copy_pixmap_region_each(ProcessInfo
*key
,
233 HashedProcessData
*value
,
236 GdkPixmap
*src
= cp
->src
;
237 GdkPixmap
*dest
= cp
->dest
;
240 dest
= value
->pixmap
;
244 gdk_draw_drawable (dest
,
248 cp
->xdest
, cp
->ydest
,
249 cp
->width
, cp
->height
);
255 void copy_pixmap_region(ProcessList
*process_list
, GdkDrawable
*dest
,
256 GdkGC
*gc
, GdkDrawable
*src
,
257 gint xsrc
, gint ysrc
,
258 gint xdest
, gint ydest
, gint width
, gint height
)
260 CopyPixmap cp
= { dest
, gc
, src
, xsrc
, ysrc
, xdest
, ydest
, width
, height
};
262 g_hash_table_foreach(process_list
->process_hash
,
263 (GHFunc
)copy_pixmap_region_each
,
269 typedef struct _RectanglePixmap
{
271 gint x
, y
, width
, height
;
275 static void rectangle_pixmap_each(ProcessInfo
*key
,
276 HashedProcessData
*value
,
280 rp
->height
= value
->height
;
282 gdk_draw_rectangle (value
->pixmap
,
286 rp
->width
, rp
->height
);
292 void rectangle_pixmap(ProcessList
*process_list
, GdkGC
*gc
,
293 gboolean filled
, gint x
, gint y
, gint width
, gint height
)
295 RectanglePixmap rp
= { filled
, x
, y
, width
, height
, gc
};
297 g_hash_table_foreach(process_list
->process_hash
,
298 (GHFunc
)rectangle_pixmap_each
,
303 /* Renders each pixmaps into on big drawable */
304 void copy_pixmap_to_screen(ProcessList
*process_list
,
308 gint width
, gint height
)
310 if(process_list
->index_to_pixmap
->len
== 0) return;
311 guint cell_height
= process_list
->cell_height
;
314 gint begin
= floor(y
/(double)cell_height
);
315 gint end
= MIN(ceil((y
+height
)/(double)cell_height
),
316 process_list
->index_to_pixmap
->len
);
319 for(i
=begin
; i
<end
; i
++) {
320 g_assert(i
<process_list
->index_to_pixmap
->len
);
321 /* Render the pixmap to the screen */
323 //(GdkPixmap*)g_ptr_array_index(process_list->index_to_pixmap, i);
324 GDK_PIXMAP(g_ptr_array_index(process_list
->index_to_pixmap
, i
));
326 gdk_draw_drawable (dest
,
346 ProcessList
*processlist_construct(void)
348 GtkTreeViewColumn
*column
;
349 GtkCellRenderer
*renderer
;
351 ProcessList
* process_list
= g_new(ProcessList
,1);
353 process_list
->number_of_process
= 0;
355 process_list
->current_hash_data
= NULL
;
357 /* Create the Process list */
358 process_list
->list_store
= gtk_list_store_new ( N_COLUMNS
,
370 process_list
->process_list_widget
=
371 gtk_tree_view_new_with_model
372 (GTK_TREE_MODEL (process_list
->list_store
));
374 g_object_unref (G_OBJECT (process_list
->list_store
));
376 gtk_tree_sortable_set_default_sort_func(
377 GTK_TREE_SORTABLE(process_list
->list_store
),
383 gtk_tree_sortable_set_sort_column_id(
384 GTK_TREE_SORTABLE(process_list
->list_store
),
385 GTK_TREE_SORTABLE_DEFAULT_SORT_COLUMN_ID
,
389 process_list
->process_hash
= g_hash_table_new_full(
390 process_list_hash_fct
, process_list_equ_fct
,
391 destroy_hash_key
, destroy_hash_data
395 gtk_tree_view_set_headers_visible(
396 GTK_TREE_VIEW(process_list
->process_list_widget
), TRUE
);
398 /* Create a column, associating the "text" attribute of the
399 * cell_renderer to the first column of the model */
400 /* Columns alignment : 0.0 : Left 0.5 : Center 1.0 : Right */
401 renderer
= gtk_cell_renderer_text_new ();
402 process_list
->renderer
= renderer
;
404 /* Add a temporary row to the model to get the cell size when the first
405 * real process is added. */
408 path
= gtk_tree_path_new_first();
409 gtk_tree_model_get_iter (gtk_tree_view_get_model(GTK_TREE_VIEW(process_list
->process_list_widget
)), &iter
, path
);
410 gtk_list_store_append(process_list
->list_store
, &iter
);
411 gtk_tree_path_free(path
);
413 process_list
->cell_height
= 0; // not ready to get size yet.
415 column
= gtk_tree_view_column_new_with_attributes ( "Process",
420 gtk_tree_view_column_set_alignment (column
, 0.0);
421 gtk_tree_view_column_set_sizing(column
, GTK_TREE_VIEW_COLUMN_GROW_ONLY
);
422 gtk_tree_view_column_set_resizable(column
, TRUE
);
423 gtk_tree_view_append_column (
424 GTK_TREE_VIEW (process_list
->process_list_widget
), column
);
426 process_list
->button
= column
->button
;
428 column
= gtk_tree_view_column_new_with_attributes ( "Brand",
433 gtk_tree_view_column_set_alignment (column
, 0.0);
434 gtk_tree_view_column_set_sizing(column
, GTK_TREE_VIEW_COLUMN_GROW_ONLY
);
435 gtk_tree_view_column_set_resizable(column
, TRUE
);
436 gtk_tree_view_append_column (
437 GTK_TREE_VIEW (process_list
->process_list_widget
), column
);
439 column
= gtk_tree_view_column_new_with_attributes ( "PID",
444 gtk_tree_view_column_set_sizing(column
, GTK_TREE_VIEW_COLUMN_GROW_ONLY
);
445 gtk_tree_view_column_set_resizable(column
, TRUE
);
446 gtk_tree_view_append_column (
447 GTK_TREE_VIEW (process_list
->process_list_widget
), column
);
449 column
= gtk_tree_view_column_new_with_attributes ( "TGID",
454 gtk_tree_view_column_set_sizing(column
, GTK_TREE_VIEW_COLUMN_GROW_ONLY
);
455 gtk_tree_view_column_set_resizable(column
, TRUE
);
456 gtk_tree_view_append_column (
457 GTK_TREE_VIEW (process_list
->process_list_widget
), column
);
459 column
= gtk_tree_view_column_new_with_attributes ( "PPID",
464 gtk_tree_view_column_set_sizing(column
, GTK_TREE_VIEW_COLUMN_GROW_ONLY
);
465 gtk_tree_view_column_set_resizable(column
, TRUE
);
466 gtk_tree_view_append_column (
467 GTK_TREE_VIEW (process_list
->process_list_widget
), column
);
469 column
= gtk_tree_view_column_new_with_attributes ( "CPU",
474 gtk_tree_view_column_set_sizing(column
, GTK_TREE_VIEW_COLUMN_GROW_ONLY
);
475 gtk_tree_view_column_set_resizable(column
, TRUE
);
476 gtk_tree_view_append_column (
477 GTK_TREE_VIEW (process_list
->process_list_widget
), column
);
479 column
= gtk_tree_view_column_new_with_attributes ( "Birth sec",
484 gtk_tree_view_column_set_sizing(column
, GTK_TREE_VIEW_COLUMN_GROW_ONLY
);
485 gtk_tree_view_column_set_resizable(column
, TRUE
);
486 gtk_tree_view_append_column (
487 GTK_TREE_VIEW (process_list
->process_list_widget
), column
);
489 //gtk_tree_view_column_set_visible(column, 0);
491 column
= gtk_tree_view_column_new_with_attributes ( "Birth nsec",
496 gtk_tree_view_column_set_sizing(column
, GTK_TREE_VIEW_COLUMN_GROW_ONLY
);
497 gtk_tree_view_column_set_resizable(column
, TRUE
);
498 gtk_tree_view_append_column (
499 GTK_TREE_VIEW (process_list
->process_list_widget
), column
);
501 column
= gtk_tree_view_column_new_with_attributes ( "TRACE",
506 gtk_tree_view_column_set_sizing(column
, GTK_TREE_VIEW_COLUMN_GROW_ONLY
);
507 gtk_tree_view_column_set_resizable(column
, TRUE
);
508 gtk_tree_view_append_column (
509 GTK_TREE_VIEW (process_list
->process_list_widget
), column
);
512 //gtk_tree_view_column_set_visible(column, 0);
514 g_object_set_data_full(
515 G_OBJECT(process_list
->process_list_widget
),
518 (GDestroyNotify
)processlist_destroy
);
520 process_list
->index_to_pixmap
= g_ptr_array_sized_new(ALLOCATE_PROCESSES
);
525 void processlist_destroy(ProcessList
*process_list
)
527 g_debug("processlist_destroy %p", process_list
);
528 g_hash_table_destroy(process_list
->process_hash
);
529 process_list
->process_hash
= NULL
;
530 g_ptr_array_free(process_list
->index_to_pixmap
, TRUE
);
532 g_free(process_list
);
533 g_debug("processlist_destroy end");
536 static gboolean
remove_hash_item(ProcessInfo
*process_info
,
537 HashedProcessData
*hashed_process_data
,
538 ProcessList
*process_list
)
542 iter
= hashed_process_data
->y_iter
;
544 gtk_list_store_remove (process_list
->list_store
, &iter
);
545 gdk_pixmap_unref(hashed_process_data
->pixmap
);
547 if(likely(process_list
->current_hash_data
!= NULL
)) {
548 if(likely(hashed_process_data
==
549 process_list
->current_hash_data
[process_info
->trace_num
][process_info
->cpu
]))
550 process_list
->current_hash_data
[process_info
->trace_num
][process_info
->cpu
] = NULL
;
552 return TRUE
; /* remove the element from the hash table */
555 void processlist_clear(ProcessList
*process_list
)
557 g_info("processlist_clear %p", process_list
);
559 g_hash_table_foreach_remove(process_list
->process_hash
,
560 (GHRFunc
)remove_hash_item
,
561 (gpointer
)process_list
);
562 process_list
->number_of_process
= 0;
563 update_index_to_pixmap(process_list
);
567 GtkWidget
*processlist_get_widget(ProcessList
*process_list
)
569 return process_list
->process_list_widget
;
573 void destroy_hash_key(gpointer key
)
578 void destroy_hash_data(gpointer data
)
584 void processlist_set_name(ProcessList
*process_list
,
586 HashedProcessData
*hashed_process_data
)
588 gtk_list_store_set ( process_list
->list_store
, &hashed_process_data
->y_iter
,
589 PROCESS_COLUMN
, g_quark_to_string(name
),
593 void processlist_set_brand(ProcessList
*process_list
,
595 HashedProcessData
*hashed_process_data
)
597 gtk_list_store_set ( process_list
->list_store
, &hashed_process_data
->y_iter
,
598 BRAND_COLUMN
, g_quark_to_string(brand
),
602 void processlist_set_tgid(ProcessList
*process_list
,
604 HashedProcessData
*hashed_process_data
)
606 gtk_list_store_set ( process_list
->list_store
, &hashed_process_data
->y_iter
,
611 void processlist_set_ppid(ProcessList
*process_list
,
613 HashedProcessData
*hashed_process_data
)
615 gtk_list_store_set ( process_list
->list_store
, &hashed_process_data
->y_iter
,
621 int processlist_add( ProcessList
*process_list
,
632 ProcessInfo
**pm_process_info
,
633 HashedProcessData
**pm_hashed_process_data
)
635 ProcessInfo
*Process_Info
= g_new(ProcessInfo
, 1);
636 HashedProcessData
*hashed_process_data
= g_new(HashedProcessData
, 1);
637 *pm_hashed_process_data
= hashed_process_data
;
638 *pm_process_info
= Process_Info
;
640 Process_Info
->pid
= pid
;
641 Process_Info
->tgid
= tgid
;
643 Process_Info
->cpu
= cpu
;
645 Process_Info
->cpu
= 0;
646 Process_Info
->ppid
= ppid
;
647 Process_Info
->birth
= *birth
;
648 Process_Info
->trace_num
= trace_num
;
650 /* When we create it from before state update, we are sure that the
651 * last event occured before the beginning of the global area.
653 * If it is created after state update, this value (0) will be
654 * overriden by the new state before anything is drawn.
656 hashed_process_data
->x
.over
= 0;
657 hashed_process_data
->x
.over_used
= FALSE
;
658 hashed_process_data
->x
.over_marked
= FALSE
;
659 hashed_process_data
->x
.middle
= 0;
660 hashed_process_data
->x
.middle_used
= FALSE
;
661 hashed_process_data
->x
.middle_marked
= FALSE
;
662 hashed_process_data
->x
.under
= 0;
663 hashed_process_data
->x
.under_used
= FALSE
;
664 hashed_process_data
->x
.under_marked
= FALSE
;
665 hashed_process_data
->next_good_time
= ltt_time_zero
;
667 if (process_list
->cell_height
== 0) {
672 path
= gtk_tree_path_new_first();
673 gtk_tree_model_get_iter (gtk_tree_view_get_model(GTK_TREE_VIEW(process_list
->process_list_widget
)), &iter
, path
);
674 gtk_tree_view_get_background_area(
675 GTK_TREE_VIEW(process_list
->process_list_widget
),
677 gtk_list_store_remove(process_list
->list_store
, &iter
);
678 gtk_tree_path_free (path
);
679 process_list
->cell_height
= rect
.height
;
682 /* Add a new row to the model */
683 gtk_list_store_append ( process_list
->list_store
,
684 &hashed_process_data
->y_iter
);
686 gtk_list_store_set ( process_list
->list_store
, &hashed_process_data
->y_iter
,
687 PROCESS_COLUMN
, g_quark_to_string(name
),
688 BRAND_COLUMN
, g_quark_to_string(brand
),
693 BIRTH_S_COLUMN
, birth
->tv_sec
,
694 BIRTH_NS_COLUMN
, birth
->tv_nsec
,
695 TRACE_COLUMN
, trace_num
,
697 //gtk_tree_view_set_model(GTK_TREE_VIEW(process_list->process_list_widget),
698 // GTK_TREE_MODEL(process_list->list_store));
699 //gtk_container_resize_children(GTK_CONTAINER(process_list->process_list_widget));
701 g_hash_table_insert(process_list
->process_hash
,
702 (gpointer
)Process_Info
,
703 (gpointer
)hashed_process_data
);
705 process_list
->number_of_process
++;
709 gtk_widget_queue_draw(process_list
->process_list_widget
);
710 path
= gtk_tree_path_new_first();
711 gtk_tree_view_get_background_area(GTK_TREE_VIEW(process_list
->process_list_widget
),
713 gtk_tree_path_free (path
);
714 process_list
->cell_height
= rect
.height
;
718 hashed_process_data
->height
= process_list
->cell_height
;
719 g_assert(hashed_process_data
->height
!= 0);
721 *height
= hashed_process_data
->height
* process_list
->number_of_process
;
723 hashed_process_data
->pixmap
=
724 gdk_pixmap_new(drawing
->drawing_area
->window
,
725 drawing
->alloc_width
,
726 hashed_process_data
->height
,
730 gdk_draw_rectangle (hashed_process_data
->pixmap
,
731 drawing
->drawing_area
->style
->black_gc
,
734 drawing
->alloc_width
,
735 hashed_process_data
->height
);
737 update_index_to_pixmap(process_list
);
743 int processlist_remove( ProcessList
*process_list
,
749 ProcessInfo process_info
;
750 HashedProcessData
*hashed_process_data
;
753 process_info
.pid
= pid
;
755 process_info
.cpu
= cpu
;
757 process_info
.cpu
= 0;
758 process_info
.birth
= *birth
;
759 process_info
.trace_num
= trace_num
;
762 hashed_process_data
=
763 (HashedProcessData
*)g_hash_table_lookup(
764 process_list
->process_hash
,
766 if(likely(hashed_process_data
!= NULL
))
768 iter
= hashed_process_data
->y_iter
;
770 gtk_list_store_remove (process_list
->list_store
, &iter
);
772 g_hash_table_remove(process_list
->process_hash
,
775 if(likely(process_list
->current_hash_data
!= NULL
)) {
776 if(likely(hashed_process_data
== process_list
->current_hash_data
[trace_num
][cpu
])) {
777 process_list
->current_hash_data
[trace_num
][cpu
] = NULL
;
781 gdk_pixmap_unref(hashed_process_data
->pixmap
);
783 update_index_to_pixmap(process_list
);
785 process_list
->number_of_process
--;
795 static inline guint
get_cpu_number_from_name(GQuark name
)
801 string
= g_quark_to_string(name
);
803 begin
= strrchr(string
, '/');
806 g_assert(begin
!= '\0');
808 cpu
= strtoul(begin
, NULL
, 10);