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,
20 /*****************************************************************************
21 * Hooks to be called by the main window *
22 *****************************************************************************/
25 /* Event hooks are the drawing hooks called during traceset read. They draw the
26 * icons, text, lines and background color corresponding to the events read.
28 * Two hooks are used for drawing : before_schedchange and after_schedchange hooks. The
29 * before_schedchange is called before the state update that occurs with an event and
30 * the after_schedchange hook is called after this state update.
32 * The before_schedchange hooks fulfill the task of drawing the visible objects that
33 * corresponds to the data accumulated by the after_schedchange hook.
35 * The after_schedchange hook accumulates the data that need to be shown on the screen
36 * (items) into a queue. Then, the next before_schedchange hook will draw what that
37 * queue contains. That's the Right Way (TM) of drawing items on the screen,
38 * because we need to draw the background first (and then add icons, text, ...
39 * over it), but we only know the length of a background region once the state
40 * corresponding to it is over, which happens to be at the next before_schedchange
43 * We also have a hook called at the end of a chunk to draw the information left
44 * undrawn in each process queue. We use the current time as end of
49 //#define PANGO_ENABLE_BACKEND
57 //#include <pango/pango.h>
59 #include <ltt/event.h>
63 #include <lttv/lttv.h>
64 #include <lttv/hook.h>
65 #include <lttv/state.h>
66 #include <lttvwindow/lttvwindow.h>
67 #include <lttvwindow/lttvwindowtraces.h>
70 #include "eventhooks.h"
72 #include "processlist.h"
74 #include "cfv-private.h"
77 #define MAX_PATH_LEN 256
81 typedef struct _ProcessAddClosure
{
86 static void process_add(gpointer key
,
90 LttvProcessState
*process
= (LttvProcessState
*)value
;
91 ProcessAddClosure
*closure
= (ProcessAddClosure
*)user_data
;
92 ControlFlowData
*control_flow_data
= closure
->cfd
;
93 guint trace_num
= closure
->trace_num
;
95 /* Add process to process list (if not present) */
98 guint y
= 0, height
= 0, pl_height
= 0;
100 ProcessList
*process_list
=
101 guicontrolflow_get_process_list(control_flow_data
);
104 birth
= process
->creation_time
;
105 const gchar
*name
= g_quark_to_string(process
->name
);
106 HashedProcessData
*hashed_process_data
= NULL
;
108 if(processlist_get_process_pixels(process_list
,
114 &hashed_process_data
) == 1)
116 /* Process not present */
117 processlist_add(process_list
,
123 &hashed_process_data
);
124 processlist_get_process_pixels(process_list
,
130 &hashed_process_data
);
131 drawing_insert_square( control_flow_data
->drawing
, y
, height
);
137 /* Action to do when background computation completed.
139 * Wait for all the awaited computations to be over.
142 gint
background_ready(void *hook_data
, void *call_data
)
144 ControlFlowData
*control_flow_data
= (ControlFlowData
*)hook_data
;
145 LttvTrace
*trace
= (LttvTrace
*)call_data
;
146 LttvTracesetContext
*tsc
=
147 lttvwindow_get_traceset_context(control_flow_data
->tab
);
149 control_flow_data
->background_info_waiting
--;
151 if(control_flow_data
->background_info_waiting
== 0) {
152 g_debug("control flow viewer : background computation data ready.");
154 drawing_clear(control_flow_data
->drawing
);
155 processlist_clear(control_flow_data
->process_list
);
156 redraw_notify(control_flow_data
, NULL
);
163 /* Request background computation. Verify if it is in progress or ready first.
164 * Only for each trace in the tab's traceset.
166 void request_background_data(ControlFlowData
*control_flow_data
)
168 LttvTracesetContext
* tsc
=
169 lttvwindow_get_traceset_context(control_flow_data
->tab
);
170 gint num_traces
= lttv_traceset_number(tsc
->ts
);
174 LttvHooks
*background_ready_hook
=
176 lttv_hooks_add(background_ready_hook
, background_ready
, control_flow_data
,
178 control_flow_data
->background_info_waiting
= 0;
180 for(i
=0;i
<num_traces
;i
++) {
181 trace
= lttv_traceset_get(tsc
->ts
, i
);
183 if(lttvwindowtraces_get_ready(g_quark_from_string("state"),trace
)==FALSE
) {
185 if(lttvwindowtraces_get_in_progress(g_quark_from_string("state"),
187 /* We first remove requests that could have been done for the same
188 * information. Happens when two viewers ask for it before servicing
191 lttvwindowtraces_background_request_remove(trace
, "state");
192 lttvwindowtraces_background_request_queue(trace
,
194 lttvwindowtraces_background_notify_queue(control_flow_data
,
198 background_ready_hook
);
199 control_flow_data
->background_info_waiting
++;
200 } else { /* in progress */
202 lttvwindowtraces_background_notify_current(control_flow_data
,
206 background_ready_hook
);
207 control_flow_data
->background_info_waiting
++;
212 lttv_hooks_destroy(background_ready_hook
);
219 * Event Viewer's constructor hook
221 * This constructor is given as a parameter to the menuitem and toolbar button
222 * registration. It creates the list.
223 * @param tab A pointer to the parent tab.
224 * @return The widget created.
227 h_guicontrolflow(Tab
*tab
)
229 g_info("h_guicontrolflow, %p", tab
);
230 ControlFlowData
*control_flow_data
= guicontrolflow() ;
232 control_flow_data
->tab
= tab
;
234 //g_debug("time width2 : %u",time_window->time_width);
235 // Unreg done in the GuiControlFlow_Destructor
236 lttvwindow_register_traceset_notify(tab
,
240 lttvwindow_register_time_window_notify(tab
,
241 update_time_window_hook
,
243 lttvwindow_register_current_time_notify(tab
,
244 update_current_time_hook
,
246 lttvwindow_register_redraw_notify(tab
,
249 lttvwindow_register_continue_notify(tab
,
252 request_background_data(control_flow_data
);
255 return guicontrolflow_get_widget(control_flow_data
) ;
259 int event_selected_hook(void *hook_data
, void *call_data
)
261 ControlFlowData
*control_flow_data
= (ControlFlowData
*) hook_data
;
262 guint
*event_number
= (guint
*) call_data
;
264 g_debug("DEBUG : event selected by main window : %u", *event_number
);
269 static __inline PropertiesLine
prepare_status_line(LttvProcessState
*process
)
271 PropertiesLine prop_line
;
272 prop_line
.line_width
= 2;
273 prop_line
.style
= GDK_LINE_SOLID
;
274 prop_line
.y
= MIDDLE
;
275 //GdkColormap *colormap = gdk_colormap_get_system();
277 g_debug("prepare_status_line for state : %s",
278 g_quark_to_string(process
->state
->s
));
280 /* color of line : status of the process */
281 if(process
->state
->s
== LTTV_STATE_UNNAMED
)
282 prop_line
.color
= drawing_colors
[COL_WHITE
];
283 else if(process
->state
->s
== LTTV_STATE_WAIT_FORK
)
284 prop_line
.color
= drawing_colors
[COL_WAIT_FORK
];
285 else if(process
->state
->s
== LTTV_STATE_WAIT_CPU
)
286 prop_line
.color
= drawing_colors
[COL_WAIT_CPU
];
287 else if(process
->state
->s
== LTTV_STATE_ZOMBIE
)
288 prop_line
.color
= drawing_colors
[COL_ZOMBIE
];
289 else if(process
->state
->s
== LTTV_STATE_WAIT
)
290 prop_line
.color
= drawing_colors
[COL_WAIT
];
291 else if(process
->state
->s
== LTTV_STATE_RUN
)
292 prop_line
.color
= drawing_colors
[COL_RUN
];
294 prop_line
.color
= drawing_colors
[COL_WHITE
];
296 //gdk_colormap_alloc_color(colormap,
307 /* before_schedchange_hook
309 * This function basically draw lines and icons. Two types of lines are drawn :
310 * one small (3 pixels?) representing the state of the process and the second
311 * type is thicker (10 pixels?) representing on which CPU a process is running
312 * (and this only in running state).
314 * Extremums of the lines :
315 * x_min : time of the last event context for this process kept in memory.
316 * x_max : time of the current event.
317 * y : middle of the process in the process list. The process is found in the
318 * list, therefore is it's position in pixels.
320 * The choice of lines'color is defined by the context of the last event for this
325 int before_schedchange_hook(void *hook_data
, void *call_data
)
327 EventsRequest
*events_request
= (EventsRequest
*)hook_data
;
328 ControlFlowData
*control_flow_data
= events_request
->viewer_data
;
329 Drawing_t
*drawing
= control_flow_data
->drawing
;
331 LttvTracefileContext
*tfc
= (LttvTracefileContext
*)call_data
;
333 LttvTracefileState
*tfs
= (LttvTracefileState
*)call_data
;
334 LttvTraceState
*ts
=(LttvTraceState
*)LTTV_TRACEFILE_CONTEXT(tfs
)->t_context
;
339 LttTime evtime
= ltt_event_time(e
);
340 TimeWindow time_window
=
341 lttvwindow_get_time_window(control_flow_data
->tab
);
343 LttTime end_time
= ltt_time_add(time_window
.start_time
,
344 time_window
.time_width
);
346 if(ltt_time_compare(evtime
, time_window
.start_time
) == -1
347 || ltt_time_compare(evtime
, end_time
) == 1)
350 guint width
= drawing
->width
;
352 if(strcmp(ltt_eventtype_name(ltt_event_eventtype(e
)),"schedchange") == 0) {
354 /* we are in a schedchange, before the state update. We must draw the
355 * items corresponding to the state before it changes : now is the right
362 LttField
*f
= ltt_event_field(e
);
364 element
= ltt_field_member(f
,0);
365 pid_out
= ltt_event_get_long_unsigned(e
,element
);
366 element
= ltt_field_member(f
,1);
367 pid_in
= ltt_event_get_long_unsigned(e
,element
);
368 g_debug("out : %u in : %u", pid_out
, pid_in
);
372 /* For the pid_out */
373 /* First, check if the current process is in the state computation
374 * process list. If it is there, that means we must add it right now and
375 * draw items from the beginning of the read for it. If it is not
376 * present, it's a new process and it was not present : it will
377 * be added after the state update. */
378 LttvProcessState
*process
;
379 process
= lttv_state_find_process(tfs
, pid_out
);
381 if(process
!= NULL
) {
382 /* Well, the process_out existed : we must get it in the process hash
383 * or add it, and draw its items.
385 /* Add process to process list (if not present) */
386 guint y
= 0, height
= 0, pl_height
= 0;
387 HashedProcessData
*hashed_process_data
= NULL
;
388 ProcessList
*process_list
=
389 guicontrolflow_get_process_list(control_flow_data
);
390 LttTime birth
= process
->creation_time
;
391 const gchar
*name
= g_quark_to_string(process
->name
);
393 if(processlist_get_process_pixels(process_list
,
397 tfc
->t_context
->index
,
400 &hashed_process_data
) == 1)
402 g_assert(pid_out
== 0 || pid_out
!= process
->ppid
);
403 /* Process not present */
404 processlist_add(process_list
,
409 tfc
->t_context
->index
,
412 &hashed_process_data
);
413 processlist_get_process_pixels(process_list
,
417 tfc
->t_context
->index
,
420 &hashed_process_data
);
421 drawing_insert_square( drawing
, y
, height
);
424 /* Now, the process is in the state hash and our own process hash.
425 * We definitely can draw the items related to the ending state.
428 /* Check if the x position is unset. In can have been left unset by
429 * a draw closure from a after chunk hook. This should never happen,
430 * because it must be set by before chunk hook to the damage_begin
433 g_assert(hashed_process_data
->x
.middle
!= -1);
436 DrawContext draw_context
;
438 convert_time_to_pixels(
439 time_window
.start_time
,
445 /* Now create the drawing context that will be used to draw
446 * items related to the last state. */
447 draw_context
.drawable
= drawing
->pixmap
;
448 draw_context
.gc
= drawing
->gc
;
449 draw_context
.pango_layout
= drawing
->pango_layout
;
450 draw_context
.drawinfo
.start
.x
= hashed_process_data
->x
.middle
;
451 draw_context
.drawinfo
.end
.x
= x
;
453 draw_context
.drawinfo
.y
.over
= y
+1;
454 draw_context
.drawinfo
.y
.middle
= y
+(height
/2);
455 draw_context
.drawinfo
.y
.under
= y
+height
;
457 draw_context
.drawinfo
.start
.offset
.over
= 0;
458 draw_context
.drawinfo
.start
.offset
.middle
= 0;
459 draw_context
.drawinfo
.start
.offset
.under
= 0;
460 draw_context
.drawinfo
.end
.offset
.over
= 0;
461 draw_context
.drawinfo
.end
.offset
.middle
= 0;
462 draw_context
.drawinfo
.end
.offset
.under
= 0;
466 PropertiesLine prop_line
= prepare_status_line(process
);
467 draw_line((void*)&prop_line
, (void*)&draw_context
);
470 /* become the last x position */
471 hashed_process_data
->x
.middle
= x
;
478 /* First, check if the current process is in the state computation
479 * process list. If it is there, that means we must add it right now and
480 * draw items from the beginning of the read for it. If it is not
481 * present, it's a new process and it was not present : it will
482 * be added after the state update. */
483 LttvProcessState
*process
;
484 process
= lttv_state_find_process(tfs
, pid_in
);
486 if(process
!= NULL
) {
487 /* Well, the process_out existed : we must get it in the process hash
488 * or add it, and draw its items.
490 /* Add process to process list (if not present) */
491 guint y
= 0, height
= 0, pl_height
= 0;
492 HashedProcessData
*hashed_process_data
= NULL
;
493 ProcessList
*process_list
=
494 guicontrolflow_get_process_list(control_flow_data
);
495 LttTime birth
= process
->creation_time
;
496 const gchar
*name
= g_quark_to_string(process
->name
);
498 if(processlist_get_process_pixels(process_list
,
502 tfc
->t_context
->index
,
505 &hashed_process_data
) == 1)
507 g_assert(pid_in
== 0 || pid_in
!= process
->ppid
);
508 /* Process not present */
509 processlist_add(process_list
,
514 tfc
->t_context
->index
,
517 &hashed_process_data
);
518 processlist_get_process_pixels(process_list
,
522 tfc
->t_context
->index
,
525 &hashed_process_data
);
526 drawing_insert_square( drawing
, y
, height
);
529 /* Now, the process is in the state hash and our own process hash.
530 * We definitely can draw the items related to the ending state.
533 /* Check if the x position is unset. In can have been left unset by
534 * a draw closure from a after chunk hook. This should never happen,
535 * because it must be set by before chunk hook to the damage_begin
538 g_assert(hashed_process_data
->x
.middle
!= -1);
541 DrawContext draw_context
;
543 convert_time_to_pixels(
544 time_window
.start_time
,
550 /* Now create the drawing context that will be used to draw
551 * items related to the last state. */
552 draw_context
.drawable
= drawing
->pixmap
;
553 draw_context
.gc
= drawing
->gc
;
554 draw_context
.pango_layout
= drawing
->pango_layout
;
555 draw_context
.drawinfo
.start
.x
= hashed_process_data
->x
.middle
;
556 draw_context
.drawinfo
.end
.x
= x
;
558 draw_context
.drawinfo
.y
.over
= y
+1;
559 draw_context
.drawinfo
.y
.middle
= y
+(height
/2);
560 draw_context
.drawinfo
.y
.under
= y
+height
;
562 draw_context
.drawinfo
.start
.offset
.over
= 0;
563 draw_context
.drawinfo
.start
.offset
.middle
= 0;
564 draw_context
.drawinfo
.start
.offset
.under
= 0;
565 draw_context
.drawinfo
.end
.offset
.over
= 0;
566 draw_context
.drawinfo
.end
.offset
.middle
= 0;
567 draw_context
.drawinfo
.end
.offset
.under
= 0;
571 PropertiesLine prop_line
= prepare_status_line(process
);
572 draw_line((void*)&prop_line
, (void*)&draw_context
);
576 /* become the last x position */
577 hashed_process_data
->x
.middle
= x
;
586 EventsRequest
*events_request
= (EventsRequest
*)hook_data
;
587 ControlFlowData
*control_flow_data
=
588 (ControlFlowData
*)events_request
->viewer_data
;
589 Tab
*tab
= control_flow_data
->tab
;
591 LttvTracefileContext
*tfc
= (LttvTracefileContext
*)call_data
;
593 LttvTracefileState
*tfs
= (LttvTracefileState
*)call_data
;
594 LttvTraceState
*ts
=(LttvTraceState
*)LTTV_TRACEFILE_CONTEXT(tfs
)->t_context
;
599 LttTime evtime
= ltt_event_time(e
);
600 TimeWindow time_window
=
601 lttvwindow_get_time_window(tab
);
603 LttTime end_time
= ltt_time_add(time_window
.start_time
,
604 time_window
.time_width
);
605 //if(time < time_beg || time > time_end) return;
606 if(ltt_time_compare(evtime
, time_window
.start_time
) == -1
607 || ltt_time_compare(evtime
, end_time
) == 1)
610 if(strcmp(ltt_eventtype_name(ltt_event_eventtype(e
)),"schedchange") == 0)
612 g_debug("schedchange!");
614 /* Add process to process list (if not present) and get drawing "y" from
615 * process position */
616 guint pid_out
, pid_in
;
617 LttvProcessState
*process_out
, *process_in
;
619 guint y_in
= 0, y_out
= 0, height
= 0, pl_height
= 0;
621 ProcessList
*process_list
=
622 guicontrolflow_get_process_list(control_flow_data
);
625 LttField
*f
= ltt_event_field(e
);
627 element
= ltt_field_member(f
,0);
628 pid_out
= ltt_event_get_long_unsigned(e
,element
);
629 element
= ltt_field_member(f
,1);
630 pid_in
= ltt_event_get_long_unsigned(e
,element
);
631 g_debug("out : %u in : %u", pid_out
, pid_in
);
634 /* Find process pid_out in the list... */
635 process_out
= lttv_state_find_process(tfs
, pid_out
);
636 if(process_out
== NULL
) return 0;
637 g_debug("out : %s",g_quark_to_string(process_out
->state
->s
));
639 birth
= process_out
->creation_time
;
640 const gchar
*name
= g_quark_to_string(process_out
->name
);
641 HashedProcessData
*hashed_process_data_out
= NULL
;
643 if(processlist_get_process_pixels(process_list
,
646 tfc
->t_context
->index
,
649 &hashed_process_data_out
) == 1)
651 /* Process not present */
652 processlist_add(process_list
,
655 tfc
->t_context
->index
,
658 &hashed_process_data_out
);
659 g_assert(processlist_get_process_pixels(process_list
,
662 tfc
->t_context
->index
,
665 &hashed_process_data_out
)==0);
666 drawing_insert_square( control_flow_data
->drawing
, y_out
, height
);
670 /* Find process pid_in in the list... */
671 process_in
= lttv_state_find_process(tfs
, pid_in
);
672 if(process_in
== NULL
) return 0;
673 g_debug("in : %s",g_quark_to_string(process_in
->state
->s
));
675 birth
= process_in
->creation_time
;
676 name
= g_quark_to_string(process_in
->name
);
677 HashedProcessData
*hashed_process_data_in
= NULL
;
679 if(processlist_get_process_pixels(process_list
,
682 tfc
->t_context
->index
,
685 &hashed_process_data_in
) == 1)
687 /* Process not present */
688 processlist_add(process_list
,
691 tfc
->t_context
->index
,
694 &hashed_process_data_in
);
695 processlist_get_process_pixels(process_list
,
698 tfc
->t_context
->index
,
701 &hashed_process_data_in
);
703 drawing_insert_square( control_flow_data
->drawing
, y_in
, height
);
708 /* Find pixels corresponding to time of the event. If the time does
709 * not fit in the window, show a warning, not supposed to happend. */
711 guint width
= control_flow_data
->drawing
->width
;
713 LttTime time
= ltt_event_time(e
);
715 LttTime window_end
= ltt_time_add(time_window
.time_width
,
716 time_window
.start_time
);
719 convert_time_to_pixels(
720 time_window
.start_time
,
725 //assert(x <= width);
727 /* draw what represents the event for outgoing process. */
729 DrawContext
*draw_context_out
= hashed_process_data_out
->draw_context
;
730 draw_context_out
->current
->modify_over
->x
= x
;
731 draw_context_out
->current
->modify_under
->x
= x
;
732 draw_context_out
->current
->modify_over
->y
= y_out
;
733 draw_context_out
->current
->modify_under
->y
= y_out
+(height
/2)+2;
734 draw_context_out
->drawable
= control_flow_data
->drawing
->pixmap
;
735 draw_context_out
->pango_layout
= control_flow_data
->drawing
->pango_layout
;
736 GtkWidget
*widget
= control_flow_data
->drawing
->drawing_area
;
737 //draw_context_out->gc = widget->style->fg_gc[GTK_WIDGET_STATE (widget)];
738 //draw_context_out->gc = gdk_gc_new(control_flow_data->drawing->pixmap);
739 //gdk_gc_copy(draw_context_out->gc, widget->style->black_gc);
740 //draw_context_out->gc = widget->style->black_gc;
742 //draw_arc((void*)&prop_arc, (void*)draw_context_out);
743 //test_draw_item(control_flow_data->drawing, control_flow_data->drawing->pixmap);
745 /* Draw the line/background of the out process */
746 if(draw_context_out
->previous
->middle
->x
== -1)
748 draw_context_out
->previous
->over
->x
=
749 control_flow_data
->drawing
->damage_begin
;
750 draw_context_out
->previous
->middle
->x
=
751 control_flow_data
->drawing
->damage_begin
;
752 draw_context_out
->previous
->under
->x
=
753 control_flow_data
->drawing
->damage_begin
;
755 g_debug("out middle x_beg : %u",control_flow_data
->drawing
->damage_begin
);
758 draw_context_out
->current
->middle
->x
= x
;
759 draw_context_out
->current
->over
->x
= x
;
760 draw_context_out
->current
->under
->x
= x
;
761 draw_context_out
->current
->middle
->y
= y_out
+ height
/2;
762 draw_context_out
->current
->over
->y
= y_out
;
763 draw_context_out
->current
->under
->y
= y_out
+ height
;
764 draw_context_out
->previous
->middle
->y
= y_out
+ height
/2;
765 draw_context_out
->previous
->over
->y
= y_out
;
766 draw_context_out
->previous
->under
->y
= y_out
+ height
;
768 draw_context_out
->drawable
= control_flow_data
->drawing
->pixmap
;
769 draw_context_out
->pango_layout
= control_flow_data
->drawing
->pango_layout
;
771 if(process_out
->state
->s
== LTTV_STATE_RUN
)
773 //draw_context_out->gc = gdk_gc_new(control_flow_data->drawing->pixmap);
774 //gdk_gc_copy(draw_context_out->gc, widget->style->black_gc);
775 draw_context_out
->gc
= control_flow_data
->drawing
->gc
;
777 PropertiesBG prop_bg
;
778 prop_bg
.color
= g_new(GdkColor
,1);
782 prop_bg
.color
->red
= 0x1515;
783 prop_bg
.color
->green
= 0x1515;
784 prop_bg
.color
->blue
= 0x8c8c;
787 prop_bg
.color
->red
= 0x4e4e;
788 prop_bg
.color
->green
= 0xa9a9;
789 prop_bg
.color
->blue
= 0xa4a4;
792 prop_bg
.color
->red
= 0x7a7a;
793 prop_bg
.color
->green
= 0x4a4a;
794 prop_bg
.color
->blue
= 0x8b8b;
797 prop_bg
.color
->red
= 0x8080;
798 prop_bg
.color
->green
= 0x7777;
799 prop_bg
.color
->blue
= 0x4747;
802 prop_bg
.color
->red
= 0xe7e7;
803 prop_bg
.color
->green
= 0xe7e7;
804 prop_bg
.color
->blue
= 0xe7e7;
807 g_debug("calling from draw_event");
808 draw_bg((void*)&prop_bg
, (void*)draw_context_out
);
809 g_free(prop_bg
.color
);
810 //gdk_gc_unref(draw_context_out->gc);
813 draw_context_out
->gc
= widget
->style
->black_gc
;
815 GdkColor colorfg_out
= { 0, 0xffff, 0x0000, 0x0000 };
816 GdkColor colorbg_out
= { 0, 0x0000, 0x0000, 0x0000 };
817 PropertiesText prop_text_out
;
818 prop_text_out
.foreground
= &colorfg_out
;
819 prop_text_out
.background
= &colorbg_out
;
820 prop_text_out
.size
= 6;
821 prop_text_out
.position
= OVER
;
823 /* color of text : status of the process */
824 if(process_out
->state
->s
== LTTV_STATE_UNNAMED
)
826 prop_text_out
.foreground
->red
= 0xffff;
827 prop_text_out
.foreground
->green
= 0xffff;
828 prop_text_out
.foreground
->blue
= 0xffff;
830 else if(process_out
->state
->s
== LTTV_STATE_WAIT_FORK
)
832 prop_text_out
.foreground
->red
= 0x0fff;
833 prop_text_out
.foreground
->green
= 0xffff;
834 prop_text_out
.foreground
->blue
= 0xfff0;
836 else if(process_out
->state
->s
== LTTV_STATE_WAIT_CPU
)
838 prop_text_out
.foreground
->red
= 0xffff;
839 prop_text_out
.foreground
->green
= 0xffff;
840 prop_text_out
.foreground
->blue
= 0x0000;
842 else if(process_out
->state
->s
== LTTV_STATE_ZOMBIE
)
844 prop_text_out
.foreground
->red
= 0xffff;
845 prop_text_out
.foreground
->green
= 0x0000;
846 prop_text_out
.foreground
->blue
= 0xffff;
848 else if(process_out
->state
->s
== LTTV_STATE_WAIT
)
850 prop_text_out
.foreground
->red
= 0xffff;
851 prop_text_out
.foreground
->green
= 0x0000;
852 prop_text_out
.foreground
->blue
= 0x0000;
854 else if(process_out
->state
->s
== LTTV_STATE_RUN
)
856 prop_text_out
.foreground
->red
= 0x0000;
857 prop_text_out
.foreground
->green
= 0xffff;
858 prop_text_out
.foreground
->blue
= 0x0000;
862 prop_text_out
.foreground
->red
= 0xffff;
863 prop_text_out
.foreground
->green
= 0xffff;
864 prop_text_out
.foreground
->blue
= 0xffff;
868 /* Print status of the process : U, WF, WC, E, W, R */
869 if(process_out
->state
->s
== LTTV_STATE_UNNAMED
)
870 prop_text_out
.text
= "U->";
871 else if(process_out
->state
->s
== LTTV_STATE_WAIT_FORK
)
872 prop_text_out
.text
= "WF->";
873 else if(process_out
->state
->s
== LTTV_STATE_WAIT_CPU
)
874 prop_text_out
.text
= "WC->";
875 else if(process_out
->state
->s
== LTTV_STATE_ZOMBIE
)
876 prop_text_out
.text
= "E->";
877 else if(process_out
->state
->s
== LTTV_STATE_WAIT
)
878 prop_text_out
.text
= "W->";
879 else if(process_out
->state
->s
== LTTV_STATE_RUN
)
880 prop_text_out
.text
= "R->";
882 prop_text_out
.text
= "U";
884 draw_text((void*)&prop_text_out
, (void*)draw_context_out
);
885 //gdk_gc_unref(draw_context_out->gc);
887 //draw_context_out->gc = gdk_gc_new(control_flow_data->drawing->pixmap);
888 //gdk_gc_copy(draw_context_out->gc, widget->style->black_gc);
889 draw_context_out
->gc
= control_flow_data
->drawing
->gc
;
891 PropertiesLine prop_line_out
;
892 prop_line_out
.color
= g_new(GdkColor
,1);
893 prop_line_out
.line_width
= 2;
894 prop_line_out
.style
= GDK_LINE_SOLID
;
895 prop_line_out
.position
= MIDDLE
;
897 g_debug("out state : %s", g_quark_to_string(process_out
->state
->s
));
899 /* color of line : status of the process */
900 if(process_out
->state
->s
== LTTV_STATE_UNNAMED
)
902 prop_line_out
.color
->red
= 0xffff;
903 prop_line_out
.color
->green
= 0xffff;
904 prop_line_out
.color
->blue
= 0xffff;
906 else if(process_out
->state
->s
== LTTV_STATE_WAIT_FORK
)
908 prop_line_out
.color
->red
= 0x0fff;
909 prop_line_out
.color
->green
= 0xffff;
910 prop_line_out
.color
->blue
= 0xfff0;
912 else if(process_out
->state
->s
== LTTV_STATE_WAIT_CPU
)
914 prop_line_out
.color
->red
= 0xffff;
915 prop_line_out
.color
->green
= 0xffff;
916 prop_line_out
.color
->blue
= 0x0000;
918 else if(process_out
->state
->s
== LTTV_STATE_ZOMBIE
)
920 prop_line_out
.color
->red
= 0xffff;
921 prop_line_out
.color
->green
= 0x0000;
922 prop_line_out
.color
->blue
= 0xffff;
924 else if(process_out
->state
->s
== LTTV_STATE_WAIT
)
926 prop_line_out
.color
->red
= 0xffff;
927 prop_line_out
.color
->green
= 0x0000;
928 prop_line_out
.color
->blue
= 0x0000;
930 else if(process_out
->state
->s
== LTTV_STATE_RUN
)
932 prop_line_out
.color
->red
= 0x0000;
933 prop_line_out
.color
->green
= 0xffff;
934 prop_line_out
.color
->blue
= 0x0000;
938 prop_line_out
.color
->red
= 0xffff;
939 prop_line_out
.color
->green
= 0xffff;
940 prop_line_out
.color
->blue
= 0xffff;
943 draw_line((void*)&prop_line_out
, (void*)draw_context_out
);
944 g_free(prop_line_out
.color
);
945 //gdk_gc_unref(draw_context_out->gc);
946 /* Note : finishing line will have to be added when trace read over. */
948 /* Finally, update the drawing context of the pid_in. */
950 DrawContext
*draw_context_in
= hashed_process_data_in
->draw_context
;
951 draw_context_in
->current
->modify_over
->x
= x
;
952 draw_context_in
->current
->modify_under
->x
= x
;
953 draw_context_in
->current
->modify_over
->y
= y_in
;
954 draw_context_in
->current
->modify_under
->y
= y_in
+(height
/2)+2;
955 draw_context_in
->drawable
= control_flow_data
->drawing
->pixmap
;
956 draw_context_in
->pango_layout
= control_flow_data
->drawing
->pango_layout
;
957 widget
= control_flow_data
->drawing
->drawing_area
;
958 //draw_context_in->gc = widget->style->fg_gc[GTK_WIDGET_STATE (widget)];
959 //draw_context_in->gc = widget->style->black_gc;
960 //draw_context_in->gc = gdk_gc_new(control_flow_data->drawing->pixmap);
961 //gdk_gc_copy(draw_context_in->gc, widget->style->black_gc);
963 //draw_arc((void*)&prop_arc, (void*)draw_context_in);
964 //test_draw_item(control_flow_data->drawing, control_flow_data->drawing->pixmap);
966 /* Draw the line/bg of the in process */
967 if(draw_context_in
->previous
->middle
->x
== -1)
969 draw_context_in
->previous
->over
->x
=
970 control_flow_data
->drawing
->damage_begin
;
971 draw_context_in
->previous
->middle
->x
=
972 control_flow_data
->drawing
->damage_begin
;
973 draw_context_in
->previous
->under
->x
=
974 control_flow_data
->drawing
->damage_begin
;
976 g_debug("in middle x_beg : %u",control_flow_data
->drawing
->damage_begin
);
980 draw_context_in
->current
->middle
->x
= x
;
981 draw_context_in
->current
->over
->x
= x
;
982 draw_context_in
->current
->under
->x
= x
;
983 draw_context_in
->current
->middle
->y
= y_in
+ height
/2;
984 draw_context_in
->current
->over
->y
= y_in
;
985 draw_context_in
->current
->under
->y
= y_in
+ height
;
986 draw_context_in
->previous
->middle
->y
= y_in
+ height
/2;
987 draw_context_in
->previous
->over
->y
= y_in
;
988 draw_context_in
->previous
->under
->y
= y_in
+ height
;
990 draw_context_in
->drawable
= control_flow_data
->drawing
->pixmap
;
991 draw_context_in
->pango_layout
= control_flow_data
->drawing
->pango_layout
;
994 if(process_in
->state
->s
== LTTV_STATE_RUN
)
996 //draw_context_in->gc = gdk_gc_new(control_flow_data->drawing->pixmap);
997 //gdk_gc_copy(draw_context_in->gc, widget->style->black_gc);
998 draw_context_in
->gc
= control_flow_data
->drawing
->gc
;
1000 PropertiesBG prop_bg
;
1001 prop_bg
.color
= g_new(GdkColor
,1);
1003 switch(tfc
->index
) {
1005 prop_bg
.color
->red
= 0x1515;
1006 prop_bg
.color
->green
= 0x1515;
1007 prop_bg
.color
->blue
= 0x8c8c;
1010 prop_bg
.color
->red
= 0x4e4e;
1011 prop_bg
.color
->green
= 0xa9a9;
1012 prop_bg
.color
->blue
= 0xa4a4;
1015 prop_bg
.color
->red
= 0x7a7a;
1016 prop_bg
.color
->green
= 0x4a4a;
1017 prop_bg
.color
->blue
= 0x8b8b;
1020 prop_bg
.color
->red
= 0x8080;
1021 prop_bg
.color
->green
= 0x7777;
1022 prop_bg
.color
->blue
= 0x4747;
1025 prop_bg
.color
->red
= 0xe7e7;
1026 prop_bg
.color
->green
= 0xe7e7;
1027 prop_bg
.color
->blue
= 0xe7e7;
1031 draw_bg((void*)&prop_bg
, (void*)draw_context_in
);
1032 g_free(prop_bg
.color
);
1033 //gdk_gc_unref(draw_context_in->gc);
1036 draw_context_in
->gc
= widget
->style
->black_gc
;
1038 GdkColor colorfg_in
= { 0, 0x0000, 0xffff, 0x0000 };
1039 GdkColor colorbg_in
= { 0, 0x0000, 0x0000, 0x0000 };
1040 PropertiesText prop_text_in
;
1041 prop_text_in
.foreground
= &colorfg_in
;
1042 prop_text_in
.background
= &colorbg_in
;
1043 prop_text_in
.size
= 6;
1044 prop_text_in
.position
= OVER
;
1046 g_debug("in state : %s", g_quark_to_string(process_in
->state
->s
));
1047 /* foreground of text : status of the process */
1048 if(process_in
->state
->s
== LTTV_STATE_UNNAMED
)
1050 prop_text_in
.foreground
->red
= 0xffff;
1051 prop_text_in
.foreground
->green
= 0xffff;
1052 prop_text_in
.foreground
->blue
= 0xffff;
1054 else if(process_in
->state
->s
== LTTV_STATE_WAIT_FORK
)
1056 prop_text_in
.foreground
->red
= 0x0fff;
1057 prop_text_in
.foreground
->green
= 0xffff;
1058 prop_text_in
.foreground
->blue
= 0xfff0;
1060 else if(process_in
->state
->s
== LTTV_STATE_WAIT_CPU
)
1062 prop_text_in
.foreground
->red
= 0xffff;
1063 prop_text_in
.foreground
->green
= 0xffff;
1064 prop_text_in
.foreground
->blue
= 0x0000;
1066 else if(process_in
->state
->s
== LTTV_STATE_ZOMBIE
)
1068 prop_text_in
.foreground
->red
= 0xffff;
1069 prop_text_in
.foreground
->green
= 0x0000;
1070 prop_text_in
.foreground
->blue
= 0xffff;
1072 else if(process_in
->state
->s
== LTTV_STATE_WAIT
)
1074 prop_text_in
.foreground
->red
= 0xffff;
1075 prop_text_in
.foreground
->green
= 0x0000;
1076 prop_text_in
.foreground
->blue
= 0x0000;
1078 else if(process_in
->state
->s
== LTTV_STATE_RUN
)
1080 prop_text_in
.foreground
->red
= 0x0000;
1081 prop_text_in
.foreground
->green
= 0xffff;
1082 prop_text_in
.foreground
->blue
= 0x0000;
1086 prop_text_in
.foreground
->red
= 0xffff;
1087 prop_text_in
.foreground
->green
= 0xffff;
1088 prop_text_in
.foreground
->blue
= 0xffff;
1093 /* Print status of the process : U, WF, WC, E, W, R */
1094 if(process_in
->state
->s
== LTTV_STATE_UNNAMED
)
1095 prop_text_in
.text
= "U->";
1096 else if(process_in
->state
->s
== LTTV_STATE_WAIT_FORK
)
1097 prop_text_in
.text
= "WF->";
1098 else if(process_in
->state
->s
== LTTV_STATE_WAIT_CPU
)
1099 prop_text_in
.text
= "WC->";
1100 else if(process_in
->state
->s
== LTTV_STATE_ZOMBIE
)
1101 prop_text_in
.text
= "E->";
1102 else if(process_in
->state
->s
== LTTV_STATE_WAIT
)
1103 prop_text_in
.text
= "W->";
1104 else if(process_in
->state
->s
== LTTV_STATE_RUN
)
1105 prop_text_in
.text
= "R->";
1107 prop_text_in
.text
= "U";
1109 draw_text((void*)&prop_text_in
, (void*)draw_context_in
);
1110 //gdk_gc_unref(draw_context_in->gc);
1112 //draw_context_in->gc = gdk_gc_new(control_flow_data->drawing->pixmap);
1113 //gdk_gc_copy(draw_context_in->gc, widget->style->black_gc);
1114 draw_context_in
->gc
= control_flow_data
->drawing
->gc
;
1116 PropertiesLine prop_line_in
;
1117 prop_line_in
.color
= g_new(GdkColor
,1);
1118 prop_line_in
.line_width
= 2;
1119 prop_line_in
.style
= GDK_LINE_SOLID
;
1120 prop_line_in
.position
= MIDDLE
;
1122 /* color of line : status of the process */
1123 if(process_in
->state
->s
== LTTV_STATE_UNNAMED
)
1125 prop_line_in
.color
->red
= 0xffff;
1126 prop_line_in
.color
->green
= 0xffff;
1127 prop_line_in
.color
->blue
= 0xffff;
1129 else if(process_in
->state
->s
== LTTV_STATE_WAIT_FORK
)
1131 prop_line_in
.color
->red
= 0x0fff;
1132 prop_line_in
.color
->green
= 0xffff;
1133 prop_line_in
.color
->blue
= 0xfff0;
1135 else if(process_in
->state
->s
== LTTV_STATE_WAIT_CPU
)
1137 prop_line_in
.color
->red
= 0xffff;
1138 prop_line_in
.color
->green
= 0xffff;
1139 prop_line_in
.color
->blue
= 0x0000;
1141 else if(process_in
->state
->s
== LTTV_STATE_ZOMBIE
)
1143 prop_line_in
.color
->red
= 0xffff;
1144 prop_line_in
.color
->green
= 0x0000;
1145 prop_line_in
.color
->blue
= 0xffff;
1147 else if(process_in
->state
->s
== LTTV_STATE_WAIT
)
1149 prop_line_in
.color
->red
= 0xffff;
1150 prop_line_in
.color
->green
= 0x0000;
1151 prop_line_in
.color
->blue
= 0x0000;
1153 else if(process_in
->state
->s
== LTTV_STATE_RUN
)
1155 prop_line_in
.color
->red
= 0x0000;
1156 prop_line_in
.color
->green
= 0xffff;
1157 prop_line_in
.color
->blue
= 0x0000;
1161 prop_line_in
.color
->red
= 0xffff;
1162 prop_line_in
.color
->green
= 0xffff;
1163 prop_line_in
.color
->blue
= 0xffff;
1166 draw_line((void*)&prop_line_in
, (void*)draw_context_in
);
1167 g_free(prop_line_in
.color
);
1168 //gdk_gc_unref(draw_context_in->gc);
1178 GString
*string
= g_string_new("");;
1179 gboolean field_names
= TRUE
, state
= TRUE
;
1181 lttv_event_to_string(e
, tfc
->tf
, string
, TRUE
, field_names
, tfs
);
1182 g_string_append_printf(string
,"\n");
1185 g_string_append_printf(string
, " %s",
1186 g_quark_to_string(tfs
->process
->state
->s
));
1189 g_info("%s",string
->str
);
1191 g_string_free(string
, TRUE
);
1193 /* End of text dump */
1198 /* after_schedchange_hook
1200 * The draw after hook is called by the reading API to have a
1201 * particular event drawn on the screen.
1202 * @param hook_data ControlFlowData structure of the viewer.
1203 * @param call_data Event context.
1205 * This function adds items to be drawn in a queue for each process.
1208 int after_schedchange_hook(void *hook_data
, void *call_data
)
1210 EventsRequest
*events_request
= (EventsRequest
*)hook_data
;
1211 ControlFlowData
*control_flow_data
= events_request
->viewer_data
;
1213 LttvTracefileContext
*tfc
= (LttvTracefileContext
*)call_data
;
1215 LttvTracefileState
*tfs
= (LttvTracefileState
*)call_data
;
1216 LttvTraceState
*ts
=(LttvTraceState
*)LTTV_TRACEFILE_CONTEXT(tfs
)->t_context
;
1221 LttTime evtime
= ltt_event_time(e
);
1222 TimeWindow time_window
=
1223 lttvwindow_get_time_window(control_flow_data
->tab
);
1225 LttTime end_time
= ltt_time_add(time_window
.start_time
,
1226 time_window
.time_width
);
1228 if(ltt_time_compare(evtime
, time_window
.start_time
) == -1
1229 || ltt_time_compare(evtime
, end_time
) == 1)
1232 guint width
= control_flow_data
->drawing
->width
;
1234 if(strcmp(ltt_eventtype_name(ltt_event_eventtype(e
)),"schedchange") == 0) {
1236 g_debug("schedchange!");
1239 /* Add process to process list (if not present) */
1240 LttvProcessState
*process_out
, *process_in
;
1242 guint y_in
= 0, y_out
= 0, height
= 0, pl_height
= 0;
1243 HashedProcessData
*hashed_process_data_in
= NULL
;
1245 ProcessList
*process_list
=
1246 guicontrolflow_get_process_list(control_flow_data
);
1251 LttField
*f
= ltt_event_field(e
);
1253 element
= ltt_field_member(f
,0);
1254 pid_out
= ltt_event_get_long_unsigned(e
,element
);
1255 element
= ltt_field_member(f
,1);
1256 pid_in
= ltt_event_get_long_unsigned(e
,element
);
1257 g_debug("out : %u in : %u", pid_out
, pid_in
);
1261 /* Find process pid_in in the list... */
1262 process_in
= lttv_state_find_process(tfs
, pid_in
);
1263 /* It should exist, because we are after the state update. */
1264 g_assert(process_in
!= NULL
);
1266 birth
= process_in
->creation_time
;
1267 const gchar
*name
= g_quark_to_string(process_in
->name
);
1269 if(processlist_get_process_pixels(process_list
,
1271 process_in
->last_cpu
,
1273 tfc
->t_context
->index
,
1276 &hashed_process_data_in
) == 1)
1278 g_assert(pid_in
== 0 || pid_in
!= process_in
->ppid
);
1279 /* Process not present */
1280 processlist_add(process_list
,
1282 process_in
->last_cpu
,
1285 tfc
->t_context
->index
,
1288 &hashed_process_data_in
);
1289 processlist_get_process_pixels(process_list
,
1291 process_in
->last_cpu
,
1293 tfc
->t_context
->index
,
1296 &hashed_process_data_in
);
1297 drawing_insert_square( control_flow_data
->drawing
, y_in
, height
);
1300 convert_time_to_pixels(
1301 time_window
.start_time
,
1305 &hashed_process_data_in
->x
.middle
);
1313 EventsRequest
*events_request
= (EventsRequest
*)hook_data
;
1314 ControlFlowData
*control_flow_data
= events_request
->viewer_data
;
1316 LttvTracefileContext
*tfc
= (LttvTracefileContext
*)call_data
;
1318 LttvTracefileState
*tfs
= (LttvTracefileState
*)call_data
;
1319 LttvTraceState
*ts
=(LttvTraceState
*)LTTV_TRACEFILE_CONTEXT(tfs
)->t_context
;
1325 LttTime evtime
= ltt_event_time(e
);
1326 TimeWindow time_window
=
1327 lttvwindow_get_time_window(control_flow_data
->tab
);
1329 LttTime end_time
= ltt_time_add(time_window
.start_time
,
1330 time_window
.time_width
);
1331 //if(time < time_beg || time > time_end) return;
1332 if(ltt_time_compare(evtime
, time_window
.start_time
) == -1
1333 || ltt_time_compare(evtime
, end_time
) == 1)
1337 if(strcmp(ltt_eventtype_name(ltt_event_eventtype(e
)),"schedchange") == 0)
1339 g_debug("schedchange!");
1341 /* Add process to process list (if not present) and get drawing "y" from
1342 * process position */
1343 guint pid_out
, pid_in
;
1344 LttvProcessState
*process_out
, *process_in
;
1346 guint y_in
= 0, y_out
= 0, height
= 0, pl_height
= 0;
1348 ProcessList
*process_list
=
1349 guicontrolflow_get_process_list(control_flow_data
);
1352 LttField
*f
= ltt_event_field(e
);
1354 element
= ltt_field_member(f
,0);
1355 pid_out
= ltt_event_get_long_unsigned(e
,element
);
1356 element
= ltt_field_member(f
,1);
1357 pid_in
= ltt_event_get_long_unsigned(e
,element
);
1358 //g_debug("out : %u in : %u", pid_out, pid_in);
1361 /* Find process pid_out in the list... */
1362 process_out
= lttv_state_find_process(tfs
, pid_out
);
1363 if(process_out
== NULL
) return 0;
1364 //g_debug("out : %s",g_quark_to_string(process_out->state->s));
1366 birth
= process_out
->creation_time
;
1367 gchar
*name
= strdup(g_quark_to_string(process_out
->name
));
1368 HashedProcessData
*hashed_process_data_out
= NULL
;
1370 if(processlist_get_process_pixels(process_list
,
1373 tfc
->t_context
->index
,
1376 &hashed_process_data_out
) == 1)
1378 /* Process not present */
1379 processlist_add(process_list
,
1382 tfc
->t_context
->index
,
1385 &hashed_process_data_out
);
1386 processlist_get_process_pixels(process_list
,
1389 tfc
->t_context
->index
,
1392 &hashed_process_data_out
);
1393 drawing_insert_square( control_flow_data
->drawing
, y_out
, height
);
1398 /* Find process pid_in in the list... */
1399 process_in
= lttv_state_find_process(tfs
, pid_in
);
1400 if(process_in
== NULL
) return 0;
1401 //g_debug("in : %s",g_quark_to_string(process_in->state->s));
1403 birth
= process_in
->creation_time
;
1404 name
= strdup(g_quark_to_string(process_in
->name
));
1405 HashedProcessData
*hashed_process_data_in
= NULL
;
1407 if(processlist_get_process_pixels(process_list
,
1410 tfc
->t_context
->index
,
1413 &hashed_process_data_in
) == 1)
1415 /* Process not present */
1416 processlist_add(process_list
,
1419 tfc
->t_context
->index
,
1422 &hashed_process_data_in
);
1423 processlist_get_process_pixels(process_list
,
1426 tfc
->t_context
->index
,
1429 &hashed_process_data_in
);
1431 drawing_insert_square( control_flow_data
->drawing
, y_in
, height
);
1436 /* Find pixels corresponding to time of the event. If the time does
1437 * not fit in the window, show a warning, not supposed to happend. */
1439 //guint width = control_flow_data->drawing->drawing_area->allocation.width;
1441 //LttTime time = ltt_event_time(e);
1443 //LttTime window_end = ltt_time_add(time_window->time_width,
1444 // time_window->start_time);
1447 //convert_time_to_pixels(
1448 // time_window->start_time,
1454 //assert(x <= width);
1456 /* draw what represents the event for outgoing process. */
1458 DrawContext
*draw_context_out
= hashed_process_data_out
->draw_context
;
1459 //draw_context_out->current->modify_over->x = x;
1460 draw_context_out
->current
->modify_over
->y
= y_out
;
1461 draw_context_out
->current
->modify_under
->y
= y_out
+(height
/2)+2;
1462 draw_context_out
->drawable
= control_flow_data
->drawing
->pixmap
;
1463 draw_context_out
->pango_layout
= control_flow_data
->drawing
->pango_layout
;
1464 GtkWidget
*widget
= control_flow_data
->drawing
->drawing_area
;
1465 //draw_context_out->gc = widget->style->fg_gc[GTK_WIDGET_STATE (widget)];
1467 //draw_arc((void*)&prop_arc, (void*)draw_context_out);
1468 //test_draw_item(control_flow_data->drawing, control_flow_data->drawing->pixmap);
1470 /*if(process_out->state->s == LTTV_STATE_RUN)
1472 draw_context_out->gc = gdk_gc_new(control_flow_data->drawing->pixmap);
1473 gdk_gc_copy(draw_context_out->gc, widget->style->black_gc);
1474 PropertiesBG prop_bg;
1475 prop_bg.color = g_new(GdkColor,1);
1477 prop_bg.color->red = 0xffff;
1478 prop_bg.color->green = 0xffff;
1479 prop_bg.color->blue = 0xffff;
1481 draw_bg((void*)&prop_bg, (void*)draw_context_out);
1482 g_free(prop_bg.color);
1483 gdk_gc_unref(draw_context_out->gc);
1486 draw_context_out
->gc
= widget
->style
->black_gc
;
1488 GdkColor colorfg_out
= { 0, 0xffff, 0x0000, 0x0000 };
1489 GdkColor colorbg_out
= { 0, 0x0000, 0x0000, 0x0000 };
1490 PropertiesText prop_text_out
;
1491 prop_text_out
.foreground
= &colorfg_out
;
1492 prop_text_out
.background
= &colorbg_out
;
1493 prop_text_out
.size
= 6;
1494 prop_text_out
.position
= OVER
;
1496 /* color of text : status of the process */
1497 if(process_out
->state
->s
== LTTV_STATE_UNNAMED
)
1499 prop_text_out
.foreground
->red
= 0xffff;
1500 prop_text_out
.foreground
->green
= 0xffff;
1501 prop_text_out
.foreground
->blue
= 0xffff;
1503 else if(process_out
->state
->s
== LTTV_STATE_WAIT_FORK
)
1505 prop_text_out
.foreground
->red
= 0x0fff;
1506 prop_text_out
.foreground
->green
= 0xffff;
1507 prop_text_out
.foreground
->blue
= 0xfff0;
1509 else if(process_out
->state
->s
== LTTV_STATE_WAIT_CPU
)
1511 prop_text_out
.foreground
->red
= 0xffff;
1512 prop_text_out
.foreground
->green
= 0xffff;
1513 prop_text_out
.foreground
->blue
= 0x0000;
1515 else if(process_out
->state
->s
== LTTV_STATE_ZOMBIE
)
1517 prop_text_out
.foreground
->red
= 0xffff;
1518 prop_text_out
.foreground
->green
= 0x0000;
1519 prop_text_out
.foreground
->blue
= 0xffff;
1521 else if(process_out
->state
->s
== LTTV_STATE_WAIT
)
1523 prop_text_out
.foreground
->red
= 0xffff;
1524 prop_text_out
.foreground
->green
= 0x0000;
1525 prop_text_out
.foreground
->blue
= 0x0000;
1527 else if(process_out
->state
->s
== LTTV_STATE_RUN
)
1529 prop_text_out
.foreground
->red
= 0x0000;
1530 prop_text_out
.foreground
->green
= 0xffff;
1531 prop_text_out
.foreground
->blue
= 0x0000;
1535 prop_text_out
.foreground
->red
= 0xffff;
1536 prop_text_out
.foreground
->green
= 0xffff;
1537 prop_text_out
.foreground
->blue
= 0xffff;
1540 /* Print status of the process : U, WF, WC, E, W, R */
1541 if(process_out
->state
->s
== LTTV_STATE_UNNAMED
)
1542 prop_text_out
.text
= "U";
1543 else if(process_out
->state
->s
== LTTV_STATE_WAIT_FORK
)
1544 prop_text_out
.text
= "WF";
1545 else if(process_out
->state
->s
== LTTV_STATE_WAIT_CPU
)
1546 prop_text_out
.text
= "WC";
1547 else if(process_out
->state
->s
== LTTV_STATE_ZOMBIE
)
1548 prop_text_out
.text
= "E";
1549 else if(process_out
->state
->s
== LTTV_STATE_WAIT
)
1550 prop_text_out
.text
= "W";
1551 else if(process_out
->state
->s
== LTTV_STATE_RUN
)
1552 prop_text_out
.text
= "R";
1554 prop_text_out
.text
= "U";
1556 draw_text((void*)&prop_text_out
, (void*)draw_context_out
);
1558 //gdk_gc_unref(draw_context_out->gc);
1560 draw_context_out
->current
->middle
->y
= y_out
+height
/2;
1561 draw_context_out
->current
->over
->y
= y_out
;
1562 draw_context_out
->current
->under
->y
= y_out
+height
;
1563 draw_context_out
->current
->status
= process_out
->state
->s
;
1565 /* for pid_out : remove previous, Prev = current, new current (default) */
1566 g_free(draw_context_out
->previous
->modify_under
);
1567 g_free(draw_context_out
->previous
->modify_middle
);
1568 g_free(draw_context_out
->previous
->modify_over
);
1569 g_free(draw_context_out
->previous
->under
);
1570 g_free(draw_context_out
->previous
->middle
);
1571 g_free(draw_context_out
->previous
->over
);
1572 g_free(draw_context_out
->previous
);
1574 draw_context_out
->previous
= draw_context_out
->current
;
1576 draw_context_out
->current
= g_new(DrawInfo
,1);
1577 draw_context_out
->current
->over
= g_new(ItemInfo
,1);
1578 draw_context_out
->current
->over
->x
= -1;
1579 draw_context_out
->current
->over
->y
= -1;
1580 draw_context_out
->current
->middle
= g_new(ItemInfo
,1);
1581 draw_context_out
->current
->middle
->x
= -1;
1582 draw_context_out
->current
->middle
->y
= -1;
1583 draw_context_out
->current
->under
= g_new(ItemInfo
,1);
1584 draw_context_out
->current
->under
->x
= -1;
1585 draw_context_out
->current
->under
->y
= -1;
1586 draw_context_out
->current
->modify_over
= g_new(ItemInfo
,1);
1587 draw_context_out
->current
->modify_over
->x
= -1;
1588 draw_context_out
->current
->modify_over
->y
= -1;
1589 draw_context_out
->current
->modify_middle
= g_new(ItemInfo
,1);
1590 draw_context_out
->current
->modify_middle
->x
= -1;
1591 draw_context_out
->current
->modify_middle
->y
= -1;
1592 draw_context_out
->current
->modify_under
= g_new(ItemInfo
,1);
1593 draw_context_out
->current
->modify_under
->x
= -1;
1594 draw_context_out
->current
->modify_under
->y
= -1;
1595 draw_context_out
->current
->status
= LTTV_STATE_UNNAMED
;
1597 /* Finally, update the drawing context of the pid_in. */
1599 DrawContext
*draw_context_in
= hashed_process_data_in
->draw_context
;
1600 //draw_context_in->current->modify_over->x = x;
1601 draw_context_in
->current
->modify_over
->y
= y_in
;
1602 draw_context_in
->current
->modify_under
->y
= y_in
+(height
/2)+2;
1603 draw_context_in
->drawable
= control_flow_data
->drawing
->pixmap
;
1604 draw_context_in
->pango_layout
= control_flow_data
->drawing
->pango_layout
;
1605 widget
= control_flow_data
->drawing
->drawing_area
;
1606 //draw_context_in->gc = widget->style->fg_gc[GTK_WIDGET_STATE (widget)];
1608 //draw_arc((void*)&prop_arc, (void*)draw_context_in);
1609 //test_draw_item(control_flow_data->drawing, control_flow_data->drawing->pixmap);
1611 /*if(process_in->state->s == LTTV_STATE_RUN)
1613 draw_context_in->gc = gdk_gc_new(control_flow_data->drawing->pixmap);
1614 gdk_gc_copy(draw_context_in->gc, widget->style->black_gc);
1615 PropertiesBG prop_bg;
1616 prop_bg.color = g_new(GdkColor,1);
1618 prop_bg.color->red = 0xffff;
1619 prop_bg.color->green = 0xffff;
1620 prop_bg.color->blue = 0xffff;
1622 draw_bg((void*)&prop_bg, (void*)draw_context_in);
1623 g_free(prop_bg.color);
1624 gdk_gc_unref(draw_context_in->gc);
1627 draw_context_in
->gc
= widget
->style
->black_gc
;
1629 GdkColor colorfg_in
= { 0, 0x0000, 0xffff, 0x0000 };
1630 GdkColor colorbg_in
= { 0, 0x0000, 0x0000, 0x0000 };
1631 PropertiesText prop_text_in
;
1632 prop_text_in
.foreground
= &colorfg_in
;
1633 prop_text_in
.background
= &colorbg_in
;
1634 prop_text_in
.size
= 6;
1635 prop_text_in
.position
= OVER
;
1637 /* foreground of text : status of the process */
1638 if(process_in
->state
->s
== LTTV_STATE_UNNAMED
)
1640 prop_text_in
.foreground
->red
= 0xffff;
1641 prop_text_in
.foreground
->green
= 0xffff;
1642 prop_text_in
.foreground
->blue
= 0xffff;
1644 else if(process_in
->state
->s
== LTTV_STATE_WAIT_FORK
)
1646 prop_text_in
.foreground
->red
= 0x0fff;
1647 prop_text_in
.foreground
->green
= 0xffff;
1648 prop_text_in
.foreground
->blue
= 0xfff0;
1650 else if(process_in
->state
->s
== LTTV_STATE_WAIT_CPU
)
1652 prop_text_in
.foreground
->red
= 0xffff;
1653 prop_text_in
.foreground
->green
= 0xffff;
1654 prop_text_in
.foreground
->blue
= 0x0000;
1656 else if(process_in
->state
->s
== LTTV_STATE_ZOMBIE
)
1658 prop_text_in
.foreground
->red
= 0xffff;
1659 prop_text_in
.foreground
->green
= 0x0000;
1660 prop_text_in
.foreground
->blue
= 0xffff;
1662 else if(process_in
->state
->s
== LTTV_STATE_WAIT
)
1664 prop_text_in
.foreground
->red
= 0xffff;
1665 prop_text_in
.foreground
->green
= 0x0000;
1666 prop_text_in
.foreground
->blue
= 0x0000;
1668 else if(process_in
->state
->s
== LTTV_STATE_RUN
)
1670 prop_text_in
.foreground
->red
= 0x0000;
1671 prop_text_in
.foreground
->green
= 0xffff;
1672 prop_text_in
.foreground
->blue
= 0x0000;
1676 prop_text_in
.foreground
->red
= 0xffff;
1677 prop_text_in
.foreground
->green
= 0xffff;
1678 prop_text_in
.foreground
->blue
= 0xffff;
1682 /* Print status of the process : U, WF, WC, E, W, R */
1683 if(process_in
->state
->s
== LTTV_STATE_UNNAMED
)
1684 prop_text_in
.text
= "U";
1685 else if(process_in
->state
->s
== LTTV_STATE_WAIT_FORK
)
1686 prop_text_in
.text
= "WF";
1687 else if(process_in
->state
->s
== LTTV_STATE_WAIT_CPU
)
1688 prop_text_in
.text
= "WC";
1689 else if(process_in
->state
->s
== LTTV_STATE_ZOMBIE
)
1690 prop_text_in
.text
= "E";
1691 else if(process_in
->state
->s
== LTTV_STATE_WAIT
)
1692 prop_text_in
.text
= "W";
1693 else if(process_in
->state
->s
== LTTV_STATE_RUN
)
1694 prop_text_in
.text
= "R";
1696 prop_text_in
.text
= "U";
1698 draw_text((void*)&prop_text_in
, (void*)draw_context_in
);
1701 if(process_in
->state
->s
== LTTV_STATE_RUN
)
1704 prop_text_in
.foreground
= &colorfg_in
;
1705 prop_text_in
.background
= &colorbg_in
;
1706 prop_text_in
.foreground
->red
= 0xffff;
1707 prop_text_in
.foreground
->green
= 0xffff;
1708 prop_text_in
.foreground
->blue
= 0xffff;
1709 prop_text_in
.size
= 6;
1710 prop_text_in
.position
= UNDER
;
1712 prop_text_in
.text
= g_new(gchar
, 260);
1713 strcpy(prop_text_in
.text
, "CPU ");
1714 snprintf(tmp
, 255, "%u", tfc
->index
);
1715 strcat(prop_text_in
.text
, tmp
);
1717 draw_text((void*)&prop_text_in
, (void*)draw_context_in
);
1718 g_free(prop_text_in
.text
);
1722 draw_context_in
->current
->middle
->y
= y_in
+height
/2;
1723 draw_context_in
->current
->over
->y
= y_in
;
1724 draw_context_in
->current
->under
->y
= y_in
+height
;
1725 draw_context_in
->current
->status
= process_in
->state
->s
;
1727 /* for pid_in : remove previous, Prev = current, new current (default) */
1728 g_free(draw_context_in
->previous
->modify_under
);
1729 g_free(draw_context_in
->previous
->modify_middle
);
1730 g_free(draw_context_in
->previous
->modify_over
);
1731 g_free(draw_context_in
->previous
->under
);
1732 g_free(draw_context_in
->previous
->middle
);
1733 g_free(draw_context_in
->previous
->over
);
1734 g_free(draw_context_in
->previous
);
1736 draw_context_in
->previous
= draw_context_in
->current
;
1738 draw_context_in
->current
= g_new(DrawInfo
,1);
1739 draw_context_in
->current
->over
= g_new(ItemInfo
,1);
1740 draw_context_in
->current
->over
->x
= -1;
1741 draw_context_in
->current
->over
->y
= -1;
1742 draw_context_in
->current
->middle
= g_new(ItemInfo
,1);
1743 draw_context_in
->current
->middle
->x
= -1;
1744 draw_context_in
->current
->middle
->y
= -1;
1745 draw_context_in
->current
->under
= g_new(ItemInfo
,1);
1746 draw_context_in
->current
->under
->x
= -1;
1747 draw_context_in
->current
->under
->y
= -1;
1748 draw_context_in
->current
->modify_over
= g_new(ItemInfo
,1);
1749 draw_context_in
->current
->modify_over
->x
= -1;
1750 draw_context_in
->current
->modify_over
->y
= -1;
1751 draw_context_in
->current
->modify_middle
= g_new(ItemInfo
,1);
1752 draw_context_in
->current
->modify_middle
->x
= -1;
1753 draw_context_in
->current
->modify_middle
->y
= -1;
1754 draw_context_in
->current
->modify_under
= g_new(ItemInfo
,1);
1755 draw_context_in
->current
->modify_under
->x
= -1;
1756 draw_context_in
->current
->modify_under
->y
= -1;
1757 draw_context_in
->current
->status
= LTTV_STATE_UNNAMED
;
1765 static __inline PropertiesLine
prepare_execmode_line(LttvProcessState
*process
)
1767 PropertiesLine prop_line
;
1768 prop_line
.line_width
= 1;
1769 prop_line
.style
= GDK_LINE_SOLID
;
1771 //GdkColormap *colormap = gdk_colormap_get_system();
1773 /* color of line : execution mode of the process */
1774 if(process
->state
->t
== LTTV_STATE_USER_MODE
)
1775 prop_line
.color
= drawing_colors
[COL_USER_MODE
];
1776 else if(process
->state
->t
== LTTV_STATE_SYSCALL
)
1777 prop_line
.color
= drawing_colors
[COL_SYSCALL
];
1778 else if(process
->state
->t
== LTTV_STATE_TRAP
)
1779 prop_line
.color
= drawing_colors
[COL_TRAP
];
1780 else if(process
->state
->t
== LTTV_STATE_IRQ
)
1781 prop_line
.color
= drawing_colors
[COL_IRQ
];
1782 else if(process
->state
->t
== LTTV_STATE_MODE_UNKNOWN
)
1783 prop_line
.color
= drawing_colors
[COL_MODE_UNKNOWN
];
1785 prop_line
.color
= drawing_colors
[COL_WHITE
];
1787 //gdk_colormap_alloc_color(colormap,
1798 /* before_execmode_hook
1800 * This function basically draw lines and icons. Two types of lines are drawn :
1801 * one small (3 pixels?) representing the state of the process and the second
1802 * type is thicker (10 pixels?) representing on which CPU a process is running
1803 * (and this only in running state).
1805 * Extremums of the lines :
1806 * x_min : time of the last event context for this process kept in memory.
1807 * x_max : time of the current event.
1808 * y : middle of the process in the process list. The process is found in the
1809 * list, therefore is it's position in pixels.
1811 * The choice of lines'color is defined by the context of the last event for this
1816 int before_execmode_hook(void *hook_data
, void *call_data
)
1818 EventsRequest
*events_request
= (EventsRequest
*)hook_data
;
1819 ControlFlowData
*control_flow_data
= events_request
->viewer_data
;
1820 Drawing_t
*drawing
= control_flow_data
->drawing
;
1822 LttvTracefileContext
*tfc
= (LttvTracefileContext
*)call_data
;
1824 LttvTracefileState
*tfs
= (LttvTracefileState
*)call_data
;
1825 LttvTraceState
*ts
=(LttvTraceState
*)LTTV_TRACEFILE_CONTEXT(tfs
)->t_context
;
1830 LttTime evtime
= ltt_event_time(e
);
1831 TimeWindow time_window
=
1832 lttvwindow_get_time_window(control_flow_data
->tab
);
1834 LttTime end_time
= ltt_time_add(time_window
.start_time
,
1835 time_window
.time_width
);
1837 if(ltt_time_compare(evtime
, time_window
.start_time
) == -1
1838 || ltt_time_compare(evtime
, end_time
) == 1)
1841 guint width
= drawing
->width
;
1843 if(strcmp(ltt_eventtype_name(ltt_event_eventtype(e
)),"syscall_entry") == 0
1844 ||strcmp(ltt_eventtype_name(ltt_event_eventtype(e
)),"syscall_exit") == 0
1845 ||strcmp(ltt_eventtype_name(ltt_event_eventtype(e
)),"trap_entry") == 0
1846 ||strcmp(ltt_eventtype_name(ltt_event_eventtype(e
)),"trap_exit") == 0
1847 ||strcmp(ltt_eventtype_name(ltt_event_eventtype(e
)),"irq_entry") == 0
1848 ||strcmp(ltt_eventtype_name(ltt_event_eventtype(e
)),"irq_exit") == 0
1851 /* we are in a execmode, before the state update. We must draw the
1852 * items corresponding to the state before it changes : now is the right
1858 LttvProcessState
*process
= tfs
->process
;
1859 g_assert(process
!= NULL
);
1861 guint pid
= process
->pid
;
1863 /* Well, the process_out existed : we must get it in the process hash
1864 * or add it, and draw its items.
1866 /* Add process to process list (if not present) */
1867 guint y
= 0, height
= 0, pl_height
= 0;
1868 HashedProcessData
*hashed_process_data
= NULL
;
1869 ProcessList
*process_list
=
1870 guicontrolflow_get_process_list(control_flow_data
);
1871 LttTime birth
= process
->creation_time
;
1872 const gchar
*name
= g_quark_to_string(process
->name
);
1874 if(processlist_get_process_pixels(process_list
,
1878 tfc
->t_context
->index
,
1881 &hashed_process_data
) == 1)
1883 g_assert(pid
== 0 || pid
!= process
->ppid
);
1884 /* Process not present */
1885 processlist_add(process_list
,
1890 tfc
->t_context
->index
,
1893 &hashed_process_data
);
1894 processlist_get_process_pixels(process_list
,
1898 tfc
->t_context
->index
,
1901 &hashed_process_data
);
1902 drawing_insert_square( drawing
, y
, height
);
1905 /* Now, the process is in the state hash and our own process hash.
1906 * We definitely can draw the items related to the ending state.
1909 /* Check if the x position is unset. In can have been left unset by
1910 * a draw closure from a after chunk hook. This should never happen,
1911 * because it must be set by before chunk hook to the damage_begin
1914 g_assert(hashed_process_data
->x
.over
!= -1);
1917 DrawContext draw_context
;
1919 convert_time_to_pixels(
1920 time_window
.start_time
,
1926 /* Now create the drawing context that will be used to draw
1927 * items related to the last state. */
1928 draw_context
.drawable
= drawing
->pixmap
;
1929 draw_context
.gc
= drawing
->gc
;
1930 draw_context
.pango_layout
= drawing
->pango_layout
;
1931 draw_context
.drawinfo
.start
.x
= hashed_process_data
->x
.over
;
1932 draw_context
.drawinfo
.end
.x
= x
;
1934 draw_context
.drawinfo
.y
.over
= y
+1;
1935 draw_context
.drawinfo
.y
.middle
= y
+(height
/2);
1936 draw_context
.drawinfo
.y
.under
= y
+height
;
1938 draw_context
.drawinfo
.start
.offset
.over
= 0;
1939 draw_context
.drawinfo
.start
.offset
.middle
= 0;
1940 draw_context
.drawinfo
.start
.offset
.under
= 0;
1941 draw_context
.drawinfo
.end
.offset
.over
= 0;
1942 draw_context
.drawinfo
.end
.offset
.middle
= 0;
1943 draw_context
.drawinfo
.end
.offset
.under
= 0;
1947 PropertiesLine prop_line
= prepare_execmode_line(process
);
1948 draw_line((void*)&prop_line
, (void*)&draw_context
);
1951 /* become the last x position */
1952 hashed_process_data
->x
.over
= x
;
1960 /* after_execmode_hook
1962 * The draw after hook is called by the reading API to have a
1963 * particular event drawn on the screen.
1964 * @param hook_data ControlFlowData structure of the viewer.
1965 * @param call_data Event context.
1967 * This function adds items to be drawn in a queue for each process.
1970 int after_execmode_hook(void *hook_data
, void *call_data
)
1972 EventsRequest
*events_request
= (EventsRequest
*)hook_data
;
1973 ControlFlowData
*control_flow_data
= events_request
->viewer_data
;
1975 LttvTracefileContext
*tfc
= (LttvTracefileContext
*)call_data
;
1977 LttvTracefileState
*tfs
= (LttvTracefileState
*)call_data
;
1978 LttvTraceState
*ts
=(LttvTraceState
*)LTTV_TRACEFILE_CONTEXT(tfs
)->t_context
;
1983 LttTime evtime
= ltt_event_time(e
);
1984 TimeWindow time_window
=
1985 lttvwindow_get_time_window(control_flow_data
->tab
);
1987 LttTime end_time
= ltt_time_add(time_window
.start_time
,
1988 time_window
.time_width
);
1990 if(ltt_time_compare(evtime
, time_window
.start_time
) == -1
1991 || ltt_time_compare(evtime
, end_time
) == 1)
1994 guint width
= control_flow_data
->drawing
->width
;
1996 if(strcmp(ltt_eventtype_name(ltt_event_eventtype(e
)),"syscall_entry") == 0
1997 ||strcmp(ltt_eventtype_name(ltt_event_eventtype(e
)),"syscall_exit") == 0
1998 ||strcmp(ltt_eventtype_name(ltt_event_eventtype(e
)),"trap_entry") == 0
1999 ||strcmp(ltt_eventtype_name(ltt_event_eventtype(e
)),"trap_exit") == 0
2000 ||strcmp(ltt_eventtype_name(ltt_event_eventtype(e
)),"irq_entry") == 0
2001 ||strcmp(ltt_eventtype_name(ltt_event_eventtype(e
)),"irq_exit") == 0
2004 g_debug("execmode!");
2007 /* Add process to process list (if not present) */
2008 LttvProcessState
*process
;
2010 guint y
= 0, height
= 0, pl_height
= 0;
2011 HashedProcessData
*hashed_process_data
= NULL
;
2013 ProcessList
*process_list
=
2014 guicontrolflow_get_process_list(control_flow_data
);
2017 /* Find process pid_in in the list... */
2018 process
= tfs
->process
;
2019 /* It should exist, because we are after the state update. */
2020 g_assert(process
!= NULL
);
2022 guint pid
= process
->pid
;
2024 birth
= process
->creation_time
;
2025 const gchar
*name
= g_quark_to_string(process
->name
);
2027 if(processlist_get_process_pixels(process_list
,
2031 tfc
->t_context
->index
,
2034 &hashed_process_data
) == 1)
2036 g_assert(pid
== 0 || pid
!= process
->ppid
);
2037 /* Process not present */
2038 processlist_add(process_list
,
2043 tfc
->t_context
->index
,
2046 &hashed_process_data
);
2047 processlist_get_process_pixels(process_list
,
2051 tfc
->t_context
->index
,
2054 &hashed_process_data
);
2055 drawing_insert_square( control_flow_data
->drawing
, y
, height
);
2058 convert_time_to_pixels(
2059 time_window
.start_time
,
2063 &hashed_process_data
->x
.over
);
2072 * Create the processlist entry for the child process. Put the last
2073 * position in x at the current time value.
2075 * @param hook_data ControlFlowData structure of the viewer.
2076 * @param call_data Event context.
2078 * This function adds items to be drawn in a queue for each process.
2081 int after_fork_hook(void *hook_data
, void *call_data
)
2083 EventsRequest
*events_request
= (EventsRequest
*)hook_data
;
2084 ControlFlowData
*control_flow_data
= events_request
->viewer_data
;
2086 LttvTracefileContext
*tfc
= (LttvTracefileContext
*)call_data
;
2088 LttvTracefileState
*tfs
= (LttvTracefileState
*)call_data
;
2089 LttvTraceState
*ts
=(LttvTraceState
*)LTTV_TRACEFILE_CONTEXT(tfs
)->t_context
;
2094 LttTime evtime
= ltt_event_time(e
);
2095 TimeWindow time_window
=
2096 lttvwindow_get_time_window(control_flow_data
->tab
);
2098 LttTime end_time
= ltt_time_add(time_window
.start_time
,
2099 time_window
.time_width
);
2101 if(ltt_time_compare(evtime
, time_window
.start_time
) == -1
2102 || ltt_time_compare(evtime
, end_time
) == 1)
2105 guint width
= control_flow_data
->drawing
->width
;
2107 if(strcmp(ltt_eventtype_name(ltt_event_eventtype(e
)),"process") == 0) {
2112 LttField
*f
= ltt_event_field(e
);
2114 element
= ltt_field_member(f
,0);
2115 sub_id
= ltt_event_get_long_unsigned(e
,element
);
2116 element
= ltt_field_member(f
,1);
2117 child_pid
= ltt_event_get_long_unsigned(e
,element
);
2120 if(sub_id
== 2) { /* fork */
2122 /* Add process to process list (if not present) */
2123 LttvProcessState
*process_child
;
2125 guint y_child
= 0, height
= 0, pl_height
= 0;
2126 HashedProcessData
*hashed_process_data_child
= NULL
;
2128 ProcessList
*process_list
=
2129 guicontrolflow_get_process_list(control_flow_data
);
2132 /* Find child in the list... */
2133 process_child
= lttv_state_find_process(tfs
, child_pid
);
2134 /* It should exist, because we are after the state update. */
2135 g_assert(process_child
!= NULL
);
2137 birth
= process_child
->creation_time
;
2138 const gchar
*name
= g_quark_to_string(process_child
->name
);
2140 if(processlist_get_process_pixels(process_list
,
2142 process_child
->last_cpu
,
2144 tfc
->t_context
->index
,
2147 &hashed_process_data_child
) == 1)
2149 g_assert(child_pid
== 0 || child_pid
!= process_child
->ppid
);
2150 /* Process not present */
2151 processlist_add(process_list
,
2153 process_child
->last_cpu
,
2154 process_child
->ppid
,
2156 tfc
->t_context
->index
,
2159 &hashed_process_data_child
);
2160 processlist_get_process_pixels(process_list
,
2162 process_child
->last_cpu
,
2164 tfc
->t_context
->index
,
2167 &hashed_process_data_child
);
2168 drawing_insert_square( control_flow_data
->drawing
, y_child
, height
);
2172 convert_time_to_pixels(
2173 time_window
.start_time
,
2178 hashed_process_data_child
->x
.over
= new_x
;
2179 hashed_process_data_child
->x
.middle
= new_x
;
2180 hashed_process_data_child
->x
.under
= new_x
;
2189 gint
update_time_window_hook(void *hook_data
, void *call_data
)
2191 ControlFlowData
*control_flow_data
= (ControlFlowData
*) hook_data
;
2192 Drawing_t
*drawing
= control_flow_data
->drawing
;
2194 const TimeWindowNotifyData
*time_window_nofify_data
=
2195 ((const TimeWindowNotifyData
*)call_data
);
2197 TimeWindow
*old_time_window
=
2198 time_window_nofify_data
->old_time_window
;
2199 TimeWindow
*new_time_window
=
2200 time_window_nofify_data
->new_time_window
;
2202 /* Update the ruler */
2203 drawing_update_ruler(control_flow_data
->drawing
,
2207 /* Two cases : zoom in/out or scrolling */
2209 /* In order to make sure we can reuse the old drawing, the scale must
2210 * be the same and the new time interval being partly located in the
2211 * currently shown time interval. (reuse is only for scrolling)
2214 g_info("Old time window HOOK : %u, %u to %u, %u",
2215 old_time_window
->start_time
.tv_sec
,
2216 old_time_window
->start_time
.tv_nsec
,
2217 old_time_window
->time_width
.tv_sec
,
2218 old_time_window
->time_width
.tv_nsec
);
2220 g_info("New time window HOOK : %u, %u to %u, %u",
2221 new_time_window
->start_time
.tv_sec
,
2222 new_time_window
->start_time
.tv_nsec
,
2223 new_time_window
->time_width
.tv_sec
,
2224 new_time_window
->time_width
.tv_nsec
);
2226 if( new_time_window
->time_width
.tv_sec
== old_time_window
->time_width
.tv_sec
2227 && new_time_window
->time_width
.tv_nsec
== old_time_window
->time_width
.tv_nsec
)
2229 /* Same scale (scrolling) */
2230 g_info("scrolling");
2231 LttTime
*ns
= &new_time_window
->start_time
;
2232 LttTime
*os
= &old_time_window
->start_time
;
2233 LttTime old_end
= ltt_time_add(old_time_window
->start_time
,
2234 old_time_window
->time_width
);
2235 LttTime new_end
= ltt_time_add(new_time_window
->start_time
,
2236 new_time_window
->time_width
);
2238 //if(ns<os+w && os+w<ns+w)
2239 //if(ns<old_end && os<ns)
2240 if(ltt_time_compare(*ns
, old_end
) == -1
2241 && ltt_time_compare(*os
, *ns
) == -1)
2243 g_info("scrolling near right");
2244 /* Scroll right, keep right part of the screen */
2246 guint width
= control_flow_data
->drawing
->width
;
2247 convert_time_to_pixels(
2254 /* Copy old data to new location */
2255 gdk_draw_drawable (control_flow_data
->drawing
->pixmap
,
2256 control_flow_data
->drawing
->drawing_area
->style
->black_gc
,
2257 control_flow_data
->drawing
->pixmap
,
2260 control_flow_data
->drawing
->width
-x
+SAFETY
, -1);
2262 if(drawing
->damage_begin
== drawing
->damage_end
)
2263 drawing
->damage_begin
= control_flow_data
->drawing
->width
-x
;
2265 drawing
->damage_begin
= 0;
2267 drawing
->damage_end
= control_flow_data
->drawing
->width
;
2269 /* Clear the data request background, but not SAFETY */
2270 gdk_draw_rectangle (control_flow_data
->drawing
->pixmap
,
2271 //control_flow_data->drawing->drawing_area->style->black_gc,
2272 control_flow_data
->drawing
->drawing_area
->style
->black_gc
,
2274 drawing
->damage_begin
+SAFETY
, 0,
2275 drawing
->damage_end
- drawing
->damage_begin
, // do not overlap
2276 control_flow_data
->drawing
->height
);
2278 gtk_widget_queue_draw_area (drawing
->drawing_area
,
2280 control_flow_data
->drawing
->width
,
2281 control_flow_data
->drawing
->height
);
2283 /* Get new data for the rest. */
2284 drawing_data_request(control_flow_data
->drawing
,
2285 &control_flow_data
->drawing
->pixmap
,
2286 drawing
->damage_begin
, 0,
2287 drawing
->damage_end
- drawing
->damage_begin
,
2288 control_flow_data
->drawing
->height
);
2291 //if(ns<os && os<ns+w)
2292 //if(ns<os && os<new_end)
2293 if(ltt_time_compare(*ns
,*os
) == -1
2294 && ltt_time_compare(*os
,new_end
) == -1)
2296 g_info("scrolling near left");
2297 /* Scroll left, keep left part of the screen */
2299 guint width
= control_flow_data
->drawing
->width
;
2300 convert_time_to_pixels(
2308 /* Copy old data to new location */
2309 gdk_draw_drawable (control_flow_data
->drawing
->pixmap
,
2310 control_flow_data
->drawing
->drawing_area
->style
->black_gc
,
2311 control_flow_data
->drawing
->pixmap
,
2316 if(drawing
->damage_begin
== drawing
->damage_end
)
2317 drawing
->damage_end
= x
;
2319 drawing
->damage_end
=
2320 control_flow_data
->drawing
->width
;
2322 drawing
->damage_begin
= 0;
2324 gdk_draw_rectangle (control_flow_data
->drawing
->pixmap
,
2325 control_flow_data
->drawing
->drawing_area
->style
->black_gc
,
2327 drawing
->damage_begin
, 0,
2328 drawing
->damage_end
- drawing
->damage_begin
, // do not overlap
2329 control_flow_data
->drawing
->height
);
2331 gtk_widget_queue_draw_area (drawing
->drawing_area
,
2333 control_flow_data
->drawing
->width
,
2334 control_flow_data
->drawing
->height
);
2337 /* Get new data for the rest. */
2338 drawing_data_request(control_flow_data
->drawing
,
2339 &control_flow_data
->drawing
->pixmap
,
2340 drawing
->damage_begin
, 0,
2341 drawing
->damage_end
- drawing
->damage_begin
,
2342 control_flow_data
->drawing
->height
);
2345 if(ltt_time_compare(*ns
,*os
) == 0)
2347 g_info("not scrolling");
2349 g_info("scrolling far");
2350 /* Cannot reuse any part of the screen : far jump */
2353 gdk_draw_rectangle (control_flow_data
->drawing
->pixmap
,
2354 control_flow_data
->drawing
->drawing_area
->style
->black_gc
,
2357 control_flow_data
->drawing
->width
+SAFETY
, // do not overlap
2358 control_flow_data
->drawing
->height
);
2360 gtk_widget_queue_draw_area (drawing
->drawing_area
,
2362 control_flow_data
->drawing
->width
,
2363 control_flow_data
->drawing
->height
);
2365 drawing
->damage_begin
= 0;
2366 drawing
->damage_end
= control_flow_data
->drawing
->width
;
2368 drawing_data_request(control_flow_data
->drawing
,
2369 &control_flow_data
->drawing
->pixmap
,
2371 control_flow_data
->drawing
->width
,
2372 control_flow_data
->drawing
->height
);
2378 /* Different scale (zoom) */
2381 gdk_draw_rectangle (control_flow_data
->drawing
->pixmap
,
2382 control_flow_data
->drawing
->drawing_area
->style
->black_gc
,
2385 control_flow_data
->drawing
->width
+SAFETY
, // do not overlap
2386 control_flow_data
->drawing
->height
);
2388 gtk_widget_queue_draw_area (drawing
->drawing_area
,
2390 control_flow_data
->drawing
->width
,
2391 control_flow_data
->drawing
->height
);
2393 drawing
->damage_begin
= 0;
2394 drawing
->damage_end
= control_flow_data
->drawing
->width
;
2396 drawing_data_request(control_flow_data
->drawing
,
2397 &control_flow_data
->drawing
->pixmap
,
2399 control_flow_data
->drawing
->width
,
2400 control_flow_data
->drawing
->height
);
2408 gint
traceset_notify(void *hook_data
, void *call_data
)
2410 ControlFlowData
*control_flow_data
= (ControlFlowData
*) hook_data
;
2411 Drawing_t
*drawing
= control_flow_data
->drawing
;
2412 GtkWidget
*widget
= drawing
->drawing_area
;
2415 drawing_clear(control_flow_data
->drawing
);
2416 processlist_clear(control_flow_data
->process_list
);
2417 redraw_notify(control_flow_data
, NULL
);
2419 request_background_data(control_flow_data
);
2421 drawing
->damage_begin
= 0;
2422 drawing
->damage_end
= drawing
->width
;
2423 if(drawing
->damage_begin
< drawing
->damage_end
)
2425 drawing_data_request(drawing
,
2427 drawing
->damage_begin
,
2429 drawing
->damage_end
-drawing
->damage_begin
,
2433 gtk_widget_queue_draw_area(drawing
->drawing_area
,
2442 gint
redraw_notify(void *hook_data
, void *call_data
)
2444 ControlFlowData
*control_flow_data
= (ControlFlowData
*) hook_data
;
2445 Drawing_t
*drawing
= control_flow_data
->drawing
;
2446 GtkWidget
*widget
= drawing
->drawing_area
;
2448 drawing
->damage_begin
= 0;
2449 drawing
->damage_end
= drawing
->width
;
2451 /* fun feature, to be separated someday... */
2452 drawing_clear(control_flow_data
->drawing
);
2453 processlist_clear(control_flow_data
->process_list
);
2456 gdk_draw_rectangle (drawing
->pixmap
,
2457 widget
->style
->black_gc
,
2460 drawing
->width
+SAFETY
,
2464 if(drawing
->damage_begin
< drawing
->damage_end
)
2466 drawing_data_request(drawing
,
2468 drawing
->damage_begin
,
2470 drawing
->damage_end
-drawing
->damage_begin
,
2474 gtk_widget_queue_draw_area(drawing
->drawing_area
,
2483 gint
continue_notify(void *hook_data
, void *call_data
)
2485 ControlFlowData
*control_flow_data
= (ControlFlowData
*) hook_data
;
2486 Drawing_t
*drawing
= control_flow_data
->drawing
;
2487 GtkWidget
*widget
= drawing
->drawing_area
;
2489 //g_assert(widget->allocation.width == drawing->damage_end);
2491 if(drawing
->damage_begin
< drawing
->damage_end
)
2493 drawing_data_request(drawing
,
2495 drawing
->damage_begin
,
2497 drawing
->damage_end
-drawing
->damage_begin
,
2505 gint
update_current_time_hook(void *hook_data
, void *call_data
)
2507 ControlFlowData
*control_flow_data
= (ControlFlowData
*)hook_data
;
2508 Drawing_t
*drawing
= control_flow_data
->drawing
;
2510 LttTime current_time
= *((LttTime
*)call_data
);
2512 TimeWindow time_window
=
2513 lttvwindow_get_time_window(control_flow_data
->tab
);
2515 LttTime time_begin
= time_window
.start_time
;
2516 LttTime width
= time_window
.time_width
;
2517 LttTime half_width
= ltt_time_div(width
,2.0);
2518 LttTime time_end
= ltt_time_add(time_begin
, width
);
2520 LttvTracesetContext
* tsc
=
2521 lttvwindow_get_traceset_context(control_flow_data
->tab
);
2523 LttTime trace_start
= tsc
->time_span
.start_time
;
2524 LttTime trace_end
= tsc
->time_span
.end_time
;
2526 g_info("New current time HOOK : %u, %u", current_time
.tv_sec
,
2527 current_time
.tv_nsec
);
2531 /* If current time is inside time interval, just move the highlight
2534 /* Else, we have to change the time interval. We have to tell it
2535 * to the main window. */
2536 /* The time interval change will take care of placing the current
2537 * time at the center of the visible area, or nearest possible if we are
2538 * at one end of the trace. */
2541 if(ltt_time_compare(current_time
, time_begin
) == -1)
2543 TimeWindow new_time_window
;
2545 if(ltt_time_compare(current_time
,
2546 ltt_time_add(trace_start
,half_width
)) == -1)
2547 time_begin
= trace_start
;
2549 time_begin
= ltt_time_sub(current_time
,half_width
);
2551 new_time_window
.start_time
= time_begin
;
2552 new_time_window
.time_width
= width
;
2554 lttvwindow_report_time_window(control_flow_data
->tab
, new_time_window
);
2556 else if(ltt_time_compare(current_time
, time_end
) == 1)
2558 TimeWindow new_time_window
;
2560 if(ltt_time_compare(current_time
, ltt_time_sub(trace_end
, half_width
)) == 1)
2561 time_begin
= ltt_time_sub(trace_end
,width
);
2563 time_begin
= ltt_time_sub(current_time
,half_width
);
2565 new_time_window
.start_time
= time_begin
;
2566 new_time_window
.time_width
= width
;
2568 lttvwindow_report_time_window(control_flow_data
->tab
, new_time_window
);
2571 //gtk_widget_queue_draw(control_flow_data->drawing->drawing_area);
2572 gtk_widget_queue_draw_area(drawing
->drawing_area
,
2580 typedef struct _ClosureData
{
2581 EventsRequest
*events_request
;
2582 LttvTracesetState
*tss
;
2587 void draw_closure(gpointer key
, gpointer value
, gpointer user_data
)
2589 ProcessInfo
*process_info
= (ProcessInfo
*)key
;
2590 HashedProcessData
*hashed_process_data
= (HashedProcessData
*)value
;
2591 ClosureData
*closure_data
= (ClosureData
*)user_data
;
2593 EventsRequest
*events_request
= closure_data
->events_request
;
2594 ControlFlowData
*control_flow_data
= events_request
->viewer_data
;
2595 Drawing_t
*drawing
= control_flow_data
->drawing
;
2597 LttvTracesetState
*tss
= closure_data
->tss
;
2598 LttvTracesetContext
*tsc
= (LttvTracesetContext
*)closure_data
->tss
;
2600 LttTime evtime
= closure_data
->end_time
;
2601 TimeWindow time_window
=
2602 lttvwindow_get_time_window(control_flow_data
->tab
);
2604 LttTime end_time
= ltt_time_add(time_window
.start_time
,
2605 time_window
.time_width
);
2607 if(ltt_time_compare(evtime
, time_window
.start_time
) == -1
2608 || ltt_time_compare(evtime
, end_time
) == 1)
2611 guint width
= drawing
->width
;
2614 /* For the process */
2615 /* First, check if the current process is in the state computation
2616 * process list. If it is there, that means we must add it right now and
2617 * draw items from the beginning of the read for it. If it is not
2618 * present, it's a new process and it was not present : it will
2619 * be added after the state update. */
2620 g_assert(lttv_traceset_number(tsc
->ts
) > 0);
2622 /* tracefiles[0] is ok here, because we draw for every PID, and
2623 * assume CPU 0 for PID 0 //FIXME */
2624 LttvTracefileState
*tfs
=
2625 (LttvTracefileState
*)tsc
->traces
[process_info
->trace_num
]->tracefiles
[0];
2627 LttvProcessState
*process
;
2628 process
= lttv_state_find_process(tfs
,
2631 if(process
!= NULL
) {
2633 /* Only draw for processes that are currently in the trace states */
2635 guint y
= 0, height
= 0, pl_height
= 0;
2636 ProcessList
*process_list
=
2637 guicontrolflow_get_process_list(control_flow_data
);
2638 LttTime birth
= process_info
->birth
;
2640 /* Should be alike when background info is ready */
2641 if(control_flow_data
->background_info_waiting
==0)
2642 g_assert(ltt_time_compare(process
->creation_time
,
2643 process_info
->birth
) == 0);
2644 const gchar
*name
= g_quark_to_string(process
->name
);
2646 /* process HAS to be present */
2647 g_assert(processlist_get_process_pixels(process_list
,
2651 process_info
->trace_num
,
2654 &hashed_process_data
) != 1);
2656 /* Now, the process is in the state hash and our own process hash.
2657 * We definitely can draw the items related to the ending state.
2660 /* Check if the x position is unset. In can have been left unset by
2661 * a draw closure from a after chunk hook. This should never happen,
2662 * because it must be set by before chunk hook to the damage_begin
2665 g_assert(hashed_process_data
->x
.over
!= -1);
2668 DrawContext draw_context
;
2670 convert_time_to_pixels(
2671 time_window
.start_time
,
2677 /* Now create the drawing context that will be used to draw
2678 * items related to the last state. */
2679 draw_context
.drawable
= drawing
->pixmap
;
2680 draw_context
.gc
= drawing
->gc
;
2681 draw_context
.pango_layout
= drawing
->pango_layout
;
2682 draw_context
.drawinfo
.end
.x
= x
;
2684 draw_context
.drawinfo
.y
.over
= y
+1;
2685 draw_context
.drawinfo
.y
.middle
= y
+(height
/2);
2686 draw_context
.drawinfo
.y
.under
= y
+height
;
2688 draw_context
.drawinfo
.start
.offset
.over
= 0;
2689 draw_context
.drawinfo
.start
.offset
.middle
= 0;
2690 draw_context
.drawinfo
.start
.offset
.under
= 0;
2691 draw_context
.drawinfo
.end
.offset
.over
= 0;
2692 draw_context
.drawinfo
.end
.offset
.middle
= 0;
2693 draw_context
.drawinfo
.end
.offset
.under
= 0;
2696 draw_context
.drawinfo
.start
.x
= hashed_process_data
->x
.over
;
2698 PropertiesLine prop_line
= prepare_execmode_line(process
);
2699 draw_line((void*)&prop_line
, (void*)&draw_context
);
2702 hashed_process_data
->x
.over
= x
;
2704 draw_context
.drawinfo
.start
.x
= hashed_process_data
->x
.middle
;
2706 PropertiesLine prop_line
= prepare_status_line(process
);
2707 draw_line((void*)&prop_line
, (void*)&draw_context
);
2711 /* special case LTTV_STATE_WAIT : CPU is unknown. */
2713 /* become the last x position */
2714 hashed_process_data
->x
.middle
= x
;
2721 int before_chunk(void *hook_data
, void *call_data
)
2723 EventsRequest
*events_request
= (EventsRequest
*)hook_data
;
2724 LttvTracesetState
*tss
= LTTV_TRACESET_STATE(call_data
);
2726 drawing_chunk_begin(events_request
, tss
);
2731 int before_request(void *hook_data
, void *call_data
)
2733 EventsRequest
*events_request
= (EventsRequest
*)hook_data
;
2734 LttvTracesetState
*tss
= LTTV_TRACESET_STATE(call_data
);
2736 drawing_data_request_begin(events_request
, tss
);
2743 * after request is necessary in addition of after chunk in order to draw
2744 * lines until the end of the screen. after chunk just draws lines until
2751 int after_request(void *hook_data
, void *call_data
)
2753 EventsRequest
*events_request
= (EventsRequest
*)hook_data
;
2754 ControlFlowData
*control_flow_data
= events_request
->viewer_data
;
2755 LttvTracesetState
*tss
= LTTV_TRACESET_STATE(call_data
);
2756 LttvTracesetContext
*tsc
= LTTV_TRACESET_CONTEXT(call_data
);
2758 ProcessList
*process_list
=
2759 guicontrolflow_get_process_list(control_flow_data
);
2760 LttTime end_time
= events_request
->end_time
;
2762 ClosureData closure_data
;
2763 closure_data
.events_request
= (EventsRequest
*)hook_data
;
2764 closure_data
.tss
= tss
;
2765 closure_data
.end_time
= end_time
;
2767 /* Draw last items */
2768 g_hash_table_foreach(process_list
->process_hash
, draw_closure
,
2769 (void*)&closure_data
);
2771 /* Request expose */
2772 drawing_request_expose(events_request
, tss
, end_time
);
2781 int after_chunk(void *hook_data
, void *call_data
)
2783 EventsRequest
*events_request
= (EventsRequest
*)hook_data
;
2784 ControlFlowData
*control_flow_data
= events_request
->viewer_data
;
2785 LttvTracesetState
*tss
= LTTV_TRACESET_STATE(call_data
);
2786 LttvTracesetContext
*tsc
= LTTV_TRACESET_CONTEXT(call_data
);
2787 LttvTracefileContext
*tfc
= lttv_traceset_context_get_current_tfc(tsc
);
2790 ProcessList
*process_list
=
2791 guicontrolflow_get_process_list(control_flow_data
);
2794 end_time
= LTT_TIME_MIN(tfc
->timestamp
, events_request
->end_time
);
2795 else /* end of traceset, or position now out of request : end */
2796 end_time
= events_request
->end_time
;
2798 ClosureData closure_data
;
2799 closure_data
.events_request
= (EventsRequest
*)hook_data
;
2800 closure_data
.tss
= tss
;
2801 closure_data
.end_time
= end_time
;
2803 /* Draw last items */
2804 g_hash_table_foreach(process_list
->process_hash
, draw_closure
,
2805 (void*)&closure_data
);
2807 /* Request expose */
2808 drawing_request_expose(events_request
, tss
, end_time
);