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
52 //#define PANGO_ENABLE_BACKEND
60 //#include <pango/pango.h>
62 #include <ltt/event.h>
64 #include <ltt/trace.h>
66 #include <lttv/lttv.h>
67 #include <lttv/hook.h>
68 #include <lttv/state.h>
69 #include <lttvwindow/lttvwindow.h>
70 #include <lttvwindow/lttvwindowtraces.h>
71 #include <lttvwindow/support.h>
74 #include "eventhooks.h"
76 #include "processlist.h"
80 #define MAX_PATH_LEN 256
81 #define STATE_LINE_WIDTH 8
82 #define COLLISION_POSITION(height) (((height - STATE_LINE_WIDTH)/2) -3)
84 extern GSList
*g_legend_list
;
87 /* Action to do when background computation completed.
89 * Wait for all the awaited computations to be over.
92 static gint
background_ready(void *hook_data
, void *call_data
)
94 ControlFlowData
*control_flow_data
= (ControlFlowData
*)hook_data
;
96 control_flow_data
->background_info_waiting
--;
98 if(control_flow_data
->background_info_waiting
== 0) {
99 g_message("control flow viewer : background computation data ready.");
101 drawing_clear(control_flow_data
->drawing
);
102 processlist_clear(control_flow_data
->process_list
);
103 gtk_widget_set_size_request(
104 control_flow_data
->drawing
->drawing_area
,
105 -1, processlist_get_height(control_flow_data
->process_list
));
106 redraw_notify(control_flow_data
, NULL
);
113 /* Request background computation. Verify if it is in progress or ready first.
114 * Only for each trace in the tab's traceset.
117 static void request_background_data(ControlFlowData
*control_flow_data
)
120 LttvTraceset
*ts
= lttvwindow_get_traceset(control_flow_data
->tab
);
121 gint num_traces
= lttv_traceset_number(ts
);
124 LttvTraceState
*tstate
;
126 LttvHooks
*background_ready_hook
= lttv_hooks_new();
127 lttv_hooks_add(background_ready_hook
, background_ready
, control_flow_data
,
129 control_flow_data
->background_info_waiting
= 0;
131 for(i
=0;i
<num_traces
;i
++) {
132 trace
= lttv_traceset_get(ts
, i
);
133 tstate
= trace
->state
;
135 if(lttvwindowtraces_get_ready(g_quark_from_string("state"),trace
)==FALSE
136 && !ts
->has_precomputed_states
) {
138 if(lttvwindowtraces_get_in_progress(g_quark_from_string("state"),
140 /* We first remove requests that could have been done for the same
141 * information. Happens when two viewers ask for it before servicing
144 if(!lttvwindowtraces_background_request_find(trace
, "state"))
145 lttvwindowtraces_background_request_queue(
146 main_window_get_widget(control_flow_data
->tab
), trace
, "state");
147 lttvwindowtraces_background_notify_queue(control_flow_data
,
151 background_ready_hook
);
152 control_flow_data
->background_info_waiting
++;
153 } else { /* in progress */
155 lttvwindowtraces_background_notify_current(control_flow_data
,
159 background_ready_hook
);
160 control_flow_data
->background_info_waiting
++;
163 /* Data ready. By its nature, this viewer doesn't need to have
164 * its data ready hook called there, because a background
165 * request is always linked with a redraw.
171 lttv_hooks_destroy(background_ready_hook
);
178 * Event Viewer's constructor hook
180 * This constructor is given as a parameter to the menuitem and toolbar button
181 * registration. It creates the list.
182 * @param tab A pointer to the parent tab.
183 * @return The widget created.
186 h_guicontrolflow(LttvPlugin
*plugin
)
188 LttvPluginTab
*ptab
= LTTV_PLUGIN_TAB(plugin
);
189 Tab
*tab
= ptab
->tab
;
190 g_info("h_guicontrolflow, %p", tab
);
191 ControlFlowData
*control_flow_data
= guicontrolflow(ptab
);
193 control_flow_data
->tab
= tab
;
195 // Unreg done in the GuiControlFlow_Destructor
196 lttvwindow_register_traceset_notify(tab
,
200 lttvwindow_register_time_window_notify(tab
,
201 update_time_window_hook
,
203 lttvwindow_register_current_time_notify(tab
,
204 update_current_time_hook
,
206 lttvwindow_register_redraw_notify(tab
,
209 lttvwindow_register_continue_notify(tab
,
212 request_background_data(control_flow_data
);
215 return guicontrolflow_get_widget(control_flow_data
) ;
219 int event_selected_hook(void *hook_data
, void *call_data
)
221 guint
*event_number
= (guint
*) call_data
;
223 g_debug("DEBUG : event selected by main window : %u", *event_number
);
228 /* Function that selects the color of status&exemode line */
229 static inline PropertiesLine
prepare_s_e_line(LttvProcessState
*process
)
231 PropertiesLine prop_line
;
232 prop_line
.line_width
= STATE_LINE_WIDTH
;
233 prop_line
.style
= GDK_LINE_SOLID
;
234 prop_line
.y
= MIDDLE
;
235 //GdkColormap *colormap = gdk_colormap_get_system();
237 if(process
->state
->s
== LTTV_STATE_RUN
) {
238 if(process
->state
->t
== LTTV_STATE_USER_MODE
)
239 prop_line
.color
= drawing_colors
[COL_RUN_USER_MODE
];
240 else if(process
->state
->t
== LTTV_STATE_SYSCALL
)
241 prop_line
.color
= drawing_colors
[COL_RUN_SYSCALL
];
242 else if(process
->state
->t
== LTTV_STATE_TRAP
)
243 prop_line
.color
= drawing_colors
[COL_RUN_TRAP
];
244 else if(process
->state
->t
== LTTV_STATE_IRQ
)
245 prop_line
.color
= drawing_colors
[COL_RUN_IRQ
];
246 else if(process
->state
->t
== LTTV_STATE_SOFT_IRQ
)
247 prop_line
.color
= drawing_colors
[COL_RUN_SOFT_IRQ
];
248 else if(process
->state
->t
== LTTV_STATE_MAYBE_SYSCALL
)
249 prop_line
.color
= drawing_colors
[COL_MODE_UNKNOWN
];
250 else if(process
->state
->t
== LTTV_STATE_MAYBE_USER_MODE
)
251 prop_line
.color
= drawing_colors
[COL_MODE_UNKNOWN
];
252 else if(process
->state
->t
== LTTV_STATE_MAYBE_TRAP
)
253 prop_line
.color
= drawing_colors
[COL_MODE_UNKNOWN
];
254 else if(process
->state
->t
== LTTV_STATE_MODE_UNKNOWN
)
255 prop_line
.color
= drawing_colors
[COL_MODE_UNKNOWN
];
257 g_assert(FALSE
); /* RUNNING MODE UNKNOWN */
258 } else if(process
->state
->s
== LTTV_STATE_WAIT
) {
259 /* We don't show if we wait while in user mode, trap, irq or syscall */
260 prop_line
.color
= drawing_colors
[COL_WAIT
];
261 } else if(process
->state
->s
== LTTV_STATE_WAIT_CPU
) {
262 /* We don't show if we wait for CPU while in user mode, trap, irq
264 prop_line
.color
= drawing_colors
[COL_WAIT_CPU
];
265 } else if(process
->state
->s
== LTTV_STATE_ZOMBIE
) {
266 prop_line
.color
= drawing_colors
[COL_ZOMBIE
];
267 } else if(process
->state
->s
== LTTV_STATE_WAIT_FORK
) {
268 prop_line
.color
= drawing_colors
[COL_WAIT_FORK
];
269 } else if(process
->state
->s
== LTTV_STATE_EXIT
) {
270 prop_line
.color
= drawing_colors
[COL_EXIT
];
271 } else if(process
->state
->s
== LTTV_STATE_UNNAMED
) {
272 prop_line
.color
= drawing_colors
[COL_UNNAMED
];
273 } else if(process
->state
->s
== LTTV_STATE_DEAD
) {
274 prop_line
.color
= drawing_colors
[COL_DEAD
];
276 g_critical("unknown state : %s", g_quark_to_string(process
->state
->s
));
277 g_assert(FALSE
); /* UNKNOWN STATE */
284 HashedProcessData
*get_hashed_process_data(ControlFlowData
*control_flow_data
,
285 LttvProcessState
*process
,
289 HashedProcessData
*hashed_process_data
= NULL
;
290 ProcessList
*process_list
= control_flow_data
->process_list
;
291 LttTime birth
= process
->creation_time
;
294 hashed_process_data
= processlist_get_process_data(process_list
,
299 if(hashed_process_data
== NULL
)
301 g_assert(pid
== 0 || pid
!= process
->ppid
);
302 ProcessInfo
*process_info
;
303 Drawing_t
*drawing
= control_flow_data
->drawing
;
304 /* Process not present */
305 processlist_add(process_list
,
317 &hashed_process_data
);
318 gtk_widget_set_size_request(drawing
->drawing_area
,
321 gtk_widget_queue_draw(drawing
->drawing_area
);
323 return hashed_process_data
;
326 void init_drawing_context(DrawContext
*draw_context
,
327 HashedProcessData
*hashed_process_data
,
332 draw_context
->drawable
= hashed_process_data
->pixmap
;
333 draw_context
->gc
= drawing
->gc
;
334 draw_context
->pango_layout
= drawing
->pango_layout
;
335 draw_context
->drawinfo
.start
.x
= hashed_process_data
->x
.middle
;
336 draw_context
->drawinfo
.end
.x
= x
;
338 draw_context
->drawinfo
.y
.over
= 1;
339 draw_context
->drawinfo
.y
.middle
= (hashed_process_data
->height
/2);
340 draw_context
->drawinfo
.y
.under
= hashed_process_data
->height
;
342 draw_context
->drawinfo
.start
.offset
.over
= 0;
343 draw_context
->drawinfo
.start
.offset
.middle
= 0;
344 draw_context
->drawinfo
.start
.offset
.under
= 0;
345 draw_context
->drawinfo
.end
.offset
.over
= 0;
346 draw_context
->drawinfo
.end
.offset
.middle
= 0;
347 draw_context
->drawinfo
.end
.offset
.under
= 0;
351 void draw_state_line(HashedProcessData
*hashed_process_data
,
352 LttvProcessState
*process
,
355 TimeWindow time_window
)
357 DrawContext draw_context
;
358 guint width
= drawing
->width
;
360 init_drawing_context(&draw_context
,
367 PropertiesLine prop_line
= prepare_s_e_line(process
);
368 draw_line((void*)&prop_line
, (void*)&draw_context
);
370 /* become the last x position */
371 hashed_process_data
->x
.middle
= x
;
372 hashed_process_data
->x
.middle_used
= TRUE
;
373 hashed_process_data
->x
.middle_marked
= FALSE
;
375 /* Calculate the next good time */
376 convert_pixels_to_time(width
, x
+1, time_window
,
377 &hashed_process_data
->next_good_time
);
381 void draw_state_items(ControlFlowData
*control_flow_data
,
382 HashedProcessData
*hashed_process_data
,
383 LttvProcessState
*process
,
388 if(likely(ltt_time_compare(hashed_process_data
->next_good_time
,
391 if(unlikely(hashed_process_data
->x
.middle_marked
== FALSE
)) {
392 TimeWindow time_window
=
393 lttvwindow_get_time_window(control_flow_data
->tab
);
396 if(ltt_time_compare(evtime
, time_window
.start_time
) == -1
397 || ltt_time_compare(evtime
, time_window
.end_time
) == 1)
400 Drawing_t
*drawing
= control_flow_data
->drawing
;
401 guint width
= drawing
->width
;
403 convert_time_to_pixels(
409 /* Draw collision indicator */
410 gdk_gc_set_foreground(drawing
->gc
, &drawing_colors
[COL_WHITE
]);
411 gdk_draw_point(hashed_process_data
->pixmap
,
414 COLLISION_POSITION(hashed_process_data
->height
));
415 hashed_process_data
->x
.middle_marked
= TRUE
;
418 TimeWindow time_window
=
419 lttvwindow_get_time_window(control_flow_data
->tab
);
422 if(ltt_time_compare(evtime
, time_window
.start_time
) == -1
423 || ltt_time_compare(evtime
, time_window
.end_time
) == 1)
426 Drawing_t
*drawing
= control_flow_data
->drawing
;
427 guint width
= drawing
->width
;
430 convert_time_to_pixels(
437 /* Jump over draw if we are at the same x position */
438 if(unlikely(x
== hashed_process_data
->x
.middle
&&
439 hashed_process_data
->x
.middle_used
))
441 if(unlikely(hashed_process_data
->x
.middle_marked
== FALSE
)) {
442 /* Draw collision indicator */
443 gdk_gc_set_foreground(drawing
->gc
, &drawing_colors
[COL_WHITE
]);
444 gdk_draw_point(hashed_process_data
->pixmap
,
447 COLLISION_POSITION(hashed_process_data
->height
));
448 hashed_process_data
->x
.middle_marked
= TRUE
;
453 draw_state_line(hashed_process_data
,
463 /* Before try-wake-up hook. A process is being woken; we need to draw its line up to this point in time
464 in that colour. This is basically like exec-state, but the change applies to a process other than that
465 which is currently running. */
467 int before_trywakeup_hook(void *hook_data
, void *call_data
)
472 event
= (LttvEvent
*) call_data
;
473 if (strcmp(lttv_traceset_get_name_from_event(event
),"sched_wakeup") != 0)
476 ControlFlowData
*control_flow_data
= (ControlFlowData
*)hook_data
;
478 LttvTraceState
*ts
= event
->state
;;
481 LttTime evtime
= lttv_event_get_timestamp(event
);
483 LttvFilter
*filter
= control_flow_data
->filter
;
489 woken_pid
= lttv_event_get_long(event
, "tid");
490 woken_cpu
= lttv_event_get_long(event
, "target_cpu");
493 if(!filter
|| !filter
->head
||
494 lttv_filter_tree_parse(filter
->head
,e
,tfc
->tf
,
495 tfc
->t_context
->t
,tfc
,NULL
,NULL
)) {
499 /* First, check if the woken process is in the state computation
500 * process list. If it is there, that means we must add it right now and
501 * draw items from the beginning of the read for it. If it is not
502 * present, it's a new process and it was not present : it will
503 * be added after the state update. TOCHECK: What does that last para mean? */
504 guint trace_num
= 0; /*TODO ybrosseau 2012-08-23: use right number */
505 LttvProcessState
*process
= lttv_state_find_process(ts
, woken_cpu
, woken_pid
);
507 if(process
!= NULL
) {
508 /* Well, the woken process existed : we must get it in the process hash
509 * or add it, and draw its items.
511 /* Add process to process list (if not present) */
513 HashedProcessData
*hashed_process_data
= get_hashed_process_data(control_flow_data
, process
, woken_pid
, trace_num
);
515 /* Now, the process is in the state hash and our own process hash.
516 * We definitely can draw the items related to the ending state.
519 draw_state_items(control_flow_data
,
534 /* before_schedchange_hook
536 * This function basically draw lines and icons. Two types of lines are drawn :
537 * one small (3 pixels?) representing the state of the process and the second
538 * type is thicker (10 pixels?) representing on which CPU a process is running
539 * (and this only in running state).
541 * Extremums of the lines :
542 * x_min : time of the last event context for this process kept in memory.
543 * x_max : time of the current event.
544 * y : middle of the process in the process list. The process is found in the
545 * list, therefore is it's position in pixels.
547 * The choice of lines'color is defined by the context of the last event for this
552 int before_schedchange_hook(void *hook_data
, void *call_data
)
557 LttvProcessState
*process
;
559 //LttvProcessState *old_process = ts->running_process[cpu];
561 guint pid_in
, pid_out
;
564 event
= (LttvEvent
*) call_data
;
565 if (strcmp(lttv_traceset_get_name_from_event(event
),"sched_switch") != 0)
568 ControlFlowData
*control_flow_data
= (ControlFlowData
*)hook_data
;
571 /* we are in a schedchange, before the state update. We must draw the
572 * items corresponding to the state before it changes : now is the right
575 cpu
= lttv_traceset_get_cpuid_from_event(event
);
578 pid_out
= lttv_event_get_long(event
, "prev_tid");
579 pid_in
= lttv_event_get_long(event
, "next_tid");
580 state_out
= lttv_event_get_long(event
, "prev_state");
581 guint trace_number
= 0;//TODO fdeslauriers 2012-07-17: // Use trace handle to know trace number
583 process
= lttv_state_find_process(ts
,cpu
,pid_out
);
584 evtime
= lttv_event_get_timestamp(event
);
585 /* For the pid_out */
586 /* First, check if the current process is in the state computation
587 * process list. If it is there, that means we must add it right now and
588 * draw items from the beginning of the read for it. If it is not
589 * present, it's a new process and it was not present : it will
590 * be added after the state update. */
592 /* unknown state, bad current pid */
594 if(process
!= NULL
) {
595 /* Well, the process_out existed : we must get it in the process hash
596 * or add it, and draw its items.
598 /* Add process to process list (if not present) */
600 HashedProcessData
*hashed_process_data
= get_hashed_process_data(control_flow_data
, process
, pid_out
, trace_number
);
602 /* Now, the process is in the state hash and our own process hash.
603 * We definitely can draw the items related to the ending state.
606 draw_state_items(control_flow_data
,
613 /* First, check if the current process is in the state computation
614 * process list. If it is there, that means we must add it right now and
615 * draw items from the beginning of the read for it. If it is not
616 * present, it's a new process and it was not present : it will
617 * be added after the state update. */
618 process
= lttv_state_find_process(ts
,cpu
,pid_in
);
620 if(process
!= NULL
) {
621 /* Well, the process existed : we must get it in the process hash
622 * or add it, and draw its items.
624 /* Add process to process list (if not present) */
626 HashedProcessData
*hashed_process_data
= get_hashed_process_data(control_flow_data
, process
, pid_in
, trace_number
);
628 //We could set the current process and hash here, but will be done
629 //by after schedchange hook
631 /* Now, the process is in the state hash and our own process hash.
632 * We definitely can draw the items related to the ending state.
634 draw_state_items(control_flow_data
,
640 g_warning("Cannot find pin_in in schedchange %u", pid_in
);
642 tfc
->target_pid
= target_pid_saved
;
643 #endif //babel_cleanup
651 GString
*string
= g_string_new("");;
652 gboolean field_names
= TRUE
, state
= TRUE
;
654 lttv_event_to_string(e
, tfc
->tf
, string
, TRUE
, field_names
, tfs
);
655 g_string_append_printf(string
,"\n");
658 g_string_append_printf(string
, " %s",
659 g_quark_to_string(tfs
->process
->state
->s
));
662 g_info("%s",string
->str
);
664 g_string_free(string
, TRUE
);
666 /* End of text dump */
671 /* after_schedchange_hook
673 * The draw after hook is called by the reading API to have a
674 * particular event drawn on the screen.
675 * @param hook_data ControlFlowData structure of the viewer.
676 * @param call_data Event context.
678 * This function adds items to be drawn in a queue for each process.
681 int after_schedchange_hook(void *hook_data
, void *call_data
)
685 event
= (LttvEvent
*) call_data
;
687 if (strcmp(lttv_traceset_get_name_from_event(event
),"sched_switch") != 0)
690 ControlFlowData
*control_flow_data
= (ControlFlowData
*) hook_data
;
693 LttvTraceState
*ts
= event
->state
;
696 LttvFilter
*filter
= control_flow_data
->filter
;
698 LttTime evtime
= lttv_event_get_timestamp(event
);
700 /* Add process to process list (if not present) */
701 LttvProcessState
*process_in
;
702 HashedProcessData
*hashed_process_data_in
= NULL
;
704 ProcessList
*process_list
= control_flow_data
->process_list
;
708 pid_in
= lttv_event_get_long(event
, "next_tid");
712 if(!filter
|| !filter
->head
||
713 lttv_filter_tree_parse(filter
->head
,e
,tfc
->tf
,
714 tfc
->t_context
->t
,tfc
,NULL
,NULL
)) {
718 /* Find process pid_in in the list... */
719 //process_in = lttv_state_find_process(ts, ANY_CPU, pid_in);
720 //process_in = tfs->process;
721 guint cpu
= lttv_traceset_get_cpuid_from_event(event
);
722 guint trace_num
= 0; /* TODO set right trace number */
723 process_in
= ts
->running_process
[cpu
];
724 /* It should exist, because we are after the state update. */
726 g_assert(process_in
!= NULL
);
728 hashed_process_data_in
= get_hashed_process_data(control_flow_data
, process_in
, pid_in
, trace_num
);
730 /* Set the current process */
731 process_list
->current_hash_data
[trace_num
][process_in
->cpu
] =
732 hashed_process_data_in
;
734 if(ltt_time_compare(hashed_process_data_in
->next_good_time
,
737 TimeWindow time_window
=
738 lttvwindow_get_time_window(control_flow_data
->tab
);
741 if(ltt_time_compare(evtime
, time_window
.start_time
) == -1
742 || ltt_time_compare(evtime
, time_window
.end_time
) == 1)
745 Drawing_t
*drawing
= control_flow_data
->drawing
;
746 guint width
= drawing
->width
;
749 convert_time_to_pixels(
755 if(hashed_process_data_in
->x
.middle
!= new_x
) {
756 hashed_process_data_in
->x
.middle
= new_x
;
757 hashed_process_data_in
->x
.middle_used
= FALSE
;
758 hashed_process_data_in
->x
.middle_marked
= FALSE
;
769 /* before_execmode_hook
771 * This function basically draw lines and icons. Two types of lines are drawn :
772 * one small (3 pixels?) representing the state of the process and the second
773 * type is thicker (10 pixels?) representing on which CPU a process is running
774 * (and this only in running state).
776 * Extremums of the lines :
777 * x_min : time of the last event context for this process kept in memory.
778 * x_max : time of the current event.
779 * y : middle of the process in the process list. The process is found in the
780 * list, therefore is it's position in pixels.
782 * The choice of lines'color is defined by the context of the last event for this
787 int before_execmode_hook(void *hook_data
, void *call_data
)
793 LttvProcessState
*process
;
795 /* we are in a execmode, before the state update. We must draw the
796 * items corresponding to the state before it changes : now is the right
800 event
= (LttvEvent
*) call_data
;
801 if ((strncmp(lttv_traceset_get_name_from_event(event
),"sys_", sizeof("sys_") - 1) == 0)
802 ||(strcmp(lttv_traceset_get_name_from_event(event
),"exit_syscall") == 0)
803 ||(strncmp(lttv_traceset_get_name_from_event(event
),"irq_handler_",sizeof("irq_handler_") -1) == 0)
804 ||(strncmp(lttv_traceset_get_name_from_event(event
),"softirq_", sizeof("softirq_") - 1) == 0)) {
806 LttTime evtime
= lttv_event_get_timestamp(event
);
807 ControlFlowData
*control_flow_data
= (ControlFlowData
*)hook_data
;
809 LttvTraceset
*traceSet
= lttvwindow_get_traceset(control_flow_data
->tab
);
811 cpu
= lttv_traceset_get_cpuid_from_event(event
);
814 guint trace_number
= 0;//TODO fdeslauriers 2012-07-17: // Use trace handle to know trace number
816 //TODO ybrosseau 2013-04-09 validate that using the running process is the right choice
817 //process = lttv_state_find_process(ts ,cpu ,pid);
818 process
= ts
->running_process
[cpu
];
820 g_assert(process
!= NULL
);
822 guint pid
= process
->pid
;
824 /* Well, the process_out existed : we must get it in the process hash
825 * or add it, and draw its items.
827 /* Add process to process list (if not present) */
828 HashedProcessData
*hashed_process_data
= NULL
;
829 ProcessList
*process_list
= control_flow_data
->process_list
;
830 if(process_list
->current_hash_data
== NULL
){//TODO fdeslauriers 2012-07-17 : should not be necessary
834 if(likely(process_list
->current_hash_data
[trace_number
][cpu
] != NULL
)) {
835 hashed_process_data
= process_list
->current_hash_data
[trace_number
][cpu
];
837 hashed_process_data
= get_hashed_process_data(control_flow_data
,
838 process
, pid
, trace_number
);
840 /* Set the current process */
841 process_list
->current_hash_data
[trace_number
][process
->cpu
] =
845 /* Now, the process is in the state hash and our own process hash.
846 * We definitely can draw the items related to the ending state.
849 draw_state_items(control_flow_data
,
859 /* before_process_exit_hook
861 * Draw lines for process event.
863 * @param hook_data ControlFlowData structure of the viewer.
864 * @param call_data Event context.
866 * This function adds items to be drawn in a queue for each process.
871 int before_process_exit_hook(void *hook_data
, void *call_data
)
876 event
= (LttvEvent
*) call_data
;
877 if (strcmp(lttv_traceset_get_name_from_event(event
),
878 "sched_process_exit") != 0)
882 ControlFlowData
*control_flow_data
= (ControlFlowData
*) hook_data
;
883 LttvTraceState
*ts
= event
->state
;
886 LttvFilter
*filter
= control_flow_data
->filter
;
887 if(filter
!= NULL
&& filter
->head
!= NULL
)
888 if(!lttv_filter_tree_parse(filter
->head
,e
,tfc
->tf
,
889 tfc
->t_context
->t
,tfc
,NULL
,NULL
))
893 LttTime evtime
= lttv_event_get_timestamp(event
);
895 /* Add process to process list (if not present) */
896 //LttvProcessState *process = tfs->process;
897 guint cpu
= lttv_traceset_get_cpuid_from_event(event
);
898 guint trace_num
= 0; /* TODO set right trace number */
900 LttvProcessState
*process
= ts
->running_process
[cpu
];
901 guint pid
= process
->pid
;
902 HashedProcessData
*hashed_process_data
= NULL
;
904 ProcessList
*process_list
= control_flow_data
->process_list
;
906 g_assert(process
!= NULL
);
908 if(likely(process_list
->current_hash_data
[trace_num
][cpu
] != NULL
)) {
909 hashed_process_data
= process_list
->current_hash_data
[trace_num
][cpu
];
911 hashed_process_data
= get_hashed_process_data(control_flow_data
,
912 process
, pid
, trace_num
);
915 /* Now, the process is in the state hash and our own process hash.
916 * We definitely can draw the items related to the ending state.
919 draw_state_items(control_flow_data
,
930 /* before_process_release_hook
932 * Draw lines for process event.
934 * @param hook_data ControlFlowData structure of the viewer.
935 * @param call_data Event context.
937 * This function adds items to be drawn in a queue for each process.
942 int before_process_release_hook(void *hook_data
, void *call_data
)
947 event
= (LttvEvent
*) call_data
;
949 if (strcmp(lttv_traceset_get_name_from_event(event
),"sched_process_free") != 0)
952 ControlFlowData
*control_flow_data
= (ControlFlowData
*) hook_data
;
955 LttvTraceState
*ts
= event
->state
;
958 LttvFilter
*filter
= control_flow_data
->filter
;
959 if(filter
!= NULL
&& filter
->head
!= NULL
)
960 if(!lttv_filter_tree_parse(filter
->head
,e
,tfc
->tf
,
961 tfc
->t_context
->t
,tfc
,NULL
,NULL
))
964 LttTime evtime
= lttv_event_get_timestamp(event
);
967 guint trace_num
= 0; /* TODO set right trace number */
971 pid
= lttv_event_get_long(event
, "tid");
974 /* Add process to process list (if not present) */
975 /* Don't care about the process if it's not in the state hash already :
976 * that means a process that has never done anything in the trace and
977 * unknown suddently gets destroyed : no state meaningful to show. */
978 LttvProcessState
*process
= lttv_state_find_process(ts
, ANY_CPU
, pid
);
980 if(process
!= NULL
) {
982 HashedProcessData
*hashed_process_data
= NULL
;
984 ProcessList
*process_list
= control_flow_data
->process_list
;
986 birth
= process
->creation_time
;
988 /* Cannot use current process : this event happens on another process,
989 * action done by the parent. */
990 hashed_process_data
= processlist_get_process_data(process_list
,
995 if(unlikely(hashed_process_data
== NULL
))
997 * Process already been scheduled out EXIT_DEAD, not in the process list
998 * anymore. Just return.
1002 /* Now, the process is in the state hash and our own process hash.
1003 * We definitely can draw the items related to the ending state.
1006 draw_state_items(control_flow_data
,
1007 hashed_process_data
,
1018 /* after_process_fork_hook
1020 * Create the processlist entry for the child process. Put the last
1021 * position in x at the current time value.
1023 * @param hook_data ControlFlowData structure of the viewer.
1024 * @param call_data Event context.
1026 * This function adds items to be drawn in a queue for each process.
1029 int after_process_fork_hook(void *hook_data
, void *call_data
)
1033 event
= (LttvEvent
*) call_data
;
1035 if (strcmp(lttv_traceset_get_name_from_event(event
),"sched_process_fork") != 0)
1038 ControlFlowData
*control_flow_data
= (ControlFlowData
*) hook_data
;
1041 LttvTraceState
*ts
= event
->state
;
1043 #ifdef BABEL_CLEANUP
1044 LttvFilter
*filter
= control_flow_data
->filter
;
1045 if(filter
!= NULL
&& filter
->head
!= NULL
)
1046 if(!lttv_filter_tree_parse(filter
->head
,e
,tfc
->tf
,
1047 tfc
->t_context
->t
,tfc
,NULL
,NULL
))
1051 LttTime evtime
= lttv_event_get_timestamp(event
);
1055 child_pid
= lttv_event_get_long(event
, "child_tid");
1058 /* Add process to process list (if not present) */
1059 LttvProcessState
*process_child
;
1060 HashedProcessData
*hashed_process_data_child
= NULL
;
1062 ProcessList
*process_list
= control_flow_data
->process_list
;
1064 /* Find child in the list... */
1065 process_child
= lttv_state_find_process(ts
, ANY_CPU
, child_pid
);
1066 /* It should exist, because we are after the state update. */
1067 g_assert(process_child
!= NULL
);
1069 guint trace_num
= 0; /* TODO put right */
1071 /* Cannot use current process, because this action is done by the parent
1073 hashed_process_data_child
= get_hashed_process_data(control_flow_data
,
1074 process_child
, child_pid
, trace_num
);
1077 processlist_set_ppid(process_list
, process_child
->ppid
,
1078 hashed_process_data_child
);
1079 processlist_set_tgid(process_list
, process_child
->tgid
,
1080 hashed_process_data_child
);
1084 if(likely(ltt_time_compare(hashed_process_data_child
->next_good_time
,
1087 TimeWindow time_window
=
1088 lttvwindow_get_time_window(control_flow_data
->tab
);
1091 if(ltt_time_compare(evtime
, time_window
.start_time
) == -1
1092 || ltt_time_compare(evtime
, time_window
.end_time
) == 1)
1094 #endif //EXTRA_CHECK
1095 Drawing_t
*drawing
= control_flow_data
->drawing
;
1096 guint width
= drawing
->width
;
1098 convert_time_to_pixels(
1104 if(likely(hashed_process_data_child
->x
.over
!= new_x
)) {
1105 hashed_process_data_child
->x
.over
= new_x
;
1106 hashed_process_data_child
->x
.over_used
= FALSE
;
1107 hashed_process_data_child
->x
.over_marked
= FALSE
;
1109 if(likely(hashed_process_data_child
->x
.middle
!= new_x
)) {
1110 hashed_process_data_child
->x
.middle
= new_x
;
1111 hashed_process_data_child
->x
.middle_used
= FALSE
;
1112 hashed_process_data_child
->x
.middle_marked
= FALSE
;
1114 if(likely(hashed_process_data_child
->x
.under
!= new_x
)) {
1115 hashed_process_data_child
->x
.under
= new_x
;
1116 hashed_process_data_child
->x
.under_used
= FALSE
;
1117 hashed_process_data_child
->x
.under_marked
= FALSE
;
1125 /* after_process_exit_hook
1127 * Create the processlist entry for the child process. Put the last
1128 * position in x at the current time value.
1130 * @param hook_data ControlFlowData structure of the viewer.
1131 * @param call_data Event context.
1133 * This function adds items to be drawn in a queue for each process.
1136 int after_process_exit_hook(void *hook_data
, void *call_data
)
1141 event
= (LttvEvent
*) call_data
;
1143 if (strcmp(lttv_traceset_get_name_from_event(event
),"sched_process_exit") != 0)
1146 ControlFlowData
*control_flow_data
= (ControlFlowData
*) hook_data
;
1148 LttvTraceState
*ts
= event
->state
;
1150 #ifdef BABEL_CLEANUP
1151 LttvFilter
*filter
= control_flow_data
->filter
;
1152 if(filter
!= NULL
&& filter
->head
!= NULL
)
1153 if(!lttv_filter_tree_parse(filter
->head
,e
,tfc
->tf
,
1154 tfc
->t_context
->t
,tfc
,NULL
,NULL
))
1158 LttTime evtime
= lttv_event_get_timestamp(event
);
1160 /* Add process to process list (if not present) */
1161 //LttvProcessState *process = tfs->process;
1162 guint cpu
= lttv_traceset_get_cpuid_from_event(event
);
1163 guint trace_num
= 0; /* TODO set right trace number */
1164 LttvProcessState
*process
= ts
->running_process
[cpu
];
1166 /* It should exist, because we are after the state update. */
1167 g_assert(process
!= NULL
);
1169 guint pid
= process
->pid
;
1171 //guint pl_height = 0;
1172 HashedProcessData
*hashed_process_data
= NULL
;
1174 ProcessList
*process_list
= control_flow_data
->process_list
;
1176 //birth = process->creation_time;
1178 if(likely(process_list
->current_hash_data
[trace_num
][cpu
] != NULL
) ){
1179 hashed_process_data
= process_list
->current_hash_data
[trace_num
][cpu
];
1181 hashed_process_data
= get_hashed_process_data(control_flow_data
,
1182 process
, pid
, trace_num
);
1185 /* Set the current process */
1186 process_list
->current_hash_data
[trace_num
][process
->cpu
] =
1187 hashed_process_data
;
1190 if(unlikely(ltt_time_compare(hashed_process_data
->next_good_time
,
1193 TimeWindow time_window
=
1194 lttvwindow_get_time_window(control_flow_data
->tab
);
1197 if(ltt_time_compare(evtime
, time_window
.start_time
) == -1
1198 || ltt_time_compare(evtime
, time_window
.end_time
) == 1)
1200 #endif //EXTRA_CHECK
1201 Drawing_t
*drawing
= control_flow_data
->drawing
;
1202 guint width
= drawing
->width
;
1204 convert_time_to_pixels(
1209 if(unlikely(hashed_process_data
->x
.middle
!= new_x
)) {
1210 hashed_process_data
->x
.middle
= new_x
;
1211 hashed_process_data
->x
.middle_used
= FALSE
;
1212 hashed_process_data
->x
.middle_marked
= FALSE
;
1220 /* Get the filename of the process to print */
1221 int after_fs_exec_hook(void *hook_data
, void *call_data
)
1223 #ifdef BABEL_CLEANUP
1224 LttvTraceHook
*th
= (LttvTraceHook
*)hook_data
;
1225 EventsRequest
*events_request
= (EventsRequest
*)th
->hook_data
;
1226 ControlFlowData
*control_flow_data
= events_request
->viewer_data
;
1228 LttvTracefileContext
*tfc
= (LttvTracefileContext
*)call_data
;
1230 LttvTracefileState
*tfs
= (LttvTracefileState
*)call_data
;
1232 LttvTraceState
*ts
= (LttvTraceState
*)tfc
->t_context
;
1235 e
= ltt_tracefile_get_event(tfc
->tf
);
1237 LttvFilter
*filter
= control_flow_data
->filter
;
1238 if(filter
!= NULL
&& filter
->head
!= NULL
)
1239 if(!lttv_filter_tree_parse(filter
->head
,e
,tfc
->tf
,
1240 tfc
->t_context
->t
,tfc
,NULL
,NULL
))
1243 guint cpu
= tfs
->cpu
;
1244 guint trace_num
= ts
->parent
.index
;
1245 LttvProcessState
*process
= ts
->running_process
[cpu
];
1246 g_assert(process
!= NULL
);
1248 guint pid
= process
->pid
;
1250 /* Well, the process_out existed : we must get it in the process hash
1251 * or add it, and draw its items.
1253 /* Add process to process list (if not present) */
1254 guint pl_height
= 0;
1255 HashedProcessData
*hashed_process_data
= NULL
;
1256 ProcessList
*process_list
= control_flow_data
->process_list
;
1257 LttTime birth
= process
->creation_time
;
1259 if(likely(process_list
->current_hash_data
[trace_num
][cpu
] != NULL
)) {
1260 hashed_process_data
= process_list
->current_hash_data
[trace_num
][cpu
];
1262 hashed_process_data
= get_hashed_process_data(control_flow_data
,
1263 process
, pid
, trace_num
);
1264 /* Set the current process */
1265 process_list
->current_hash_data
[trace_num
][process
->cpu
] =
1266 hashed_process_data
;
1269 processlist_set_name(process_list
, process
->name
, hashed_process_data
);
1271 #endif //babel_cleanup
1276 /* after_event_enum_process_hook
1278 * Create the processlist entry for the child process. Put the last
1279 * position in x at the current time value.
1281 * @param hook_data ControlFlowData structure of the viewer.
1282 * @param call_data Event context.
1284 * This function adds items to be drawn in a queue for each process.
1287 int after_event_enum_process_hook(void *hook_data
, void *call_data
)
1291 event
= (LttvEvent
*) call_data
;
1293 if (strcmp(lttv_traceset_get_name_from_event(event
),"lttng_statedump_process_state") != 0)
1296 ControlFlowData
*control_flow_data
= (ControlFlowData
*) hook_data
;
1299 LttvTraceState
*ts
= event
->state
;
1301 guint first_cpu
, nb_cpus
, cpu
;
1303 #ifdef BABEL_CLEANUP
1304 LttvFilter
*filter
= control_flow_data
->filter
;
1305 if(filter
!= NULL
&& filter
->head
!= NULL
)
1306 if(!lttv_filter_tree_parse(filter
->head
,e
,tfc
->tf
,
1307 tfc
->t_context
->t
,tfc
,NULL
,NULL
))
1310 /* Add process to process list (if not present) */
1311 LttvProcessState
*process_in
;
1312 HashedProcessData
*hashed_process_data_in
= NULL
;
1314 ProcessList
*process_list
= control_flow_data
->process_list
;
1315 guint trace_num
= 0; /* TODO put right trace number */
1319 pid_in
= lttv_event_get_long(event
, "tid");
1324 nb_cpus
= lttv_trace_get_num_cpu(ts
->trace
);
1326 first_cpu
= ANY_CPU
;
1327 nb_cpus
= ANY_CPU
+1;
1330 for(cpu
= first_cpu
; cpu
< nb_cpus
; cpu
++) {
1331 /* Find process pid_in in the list... */
1332 process_in
= lttv_state_find_process(ts
, cpu
, pid_in
);
1333 //process_in = tfs->process;
1334 //guint cpu = tfs->cpu;
1335 //guint trace_num = ts->parent.index;
1336 //process_in = ts->running_process[cpu];
1337 /* It should exist, because we are after the state update. */
1339 //g_assert(process_in != NULL);
1340 #endif //EXTRA_CHECK
1342 hashed_process_data_in
= get_hashed_process_data(control_flow_data
,
1343 process_in
, pid_in
, trace_num
);
1345 processlist_set_name(process_list
, process_in
->name
,
1346 hashed_process_data_in
);
1347 processlist_set_ppid(process_list
, process_in
->ppid
,
1348 hashed_process_data_in
);
1349 processlist_set_tgid(process_list
, process_in
->tgid
,
1350 hashed_process_data_in
);
1357 gint
update_time_window_hook(void *hook_data
, void *call_data
)
1359 ControlFlowData
*control_flow_data
= (ControlFlowData
*) hook_data
;
1361 Drawing_t
*drawing
= control_flow_data
->drawing
;
1362 ProcessList
*process_list
= control_flow_data
->process_list
;
1364 const TimeWindowNotifyData
*time_window_nofify_data
=
1365 ((const TimeWindowNotifyData
*)call_data
);
1367 TimeWindow
*old_time_window
=
1368 time_window_nofify_data
->old_time_window
;
1369 TimeWindow
*new_time_window
=
1370 time_window_nofify_data
->new_time_window
;
1372 /* Update the ruler */
1373 drawing_update_ruler(control_flow_data
->drawing
,
1377 /* Two cases : zoom in/out or scrolling */
1379 /* In order to make sure we can reuse the old drawing, the scale must
1380 * be the same and the new time interval being partly located in the
1381 * currently shown time interval. (reuse is only for scrolling)
1384 g_info("Old time window HOOK : %lu, %lu to %lu, %lu",
1385 old_time_window
->start_time
.tv_sec
,
1386 old_time_window
->start_time
.tv_nsec
,
1387 old_time_window
->time_width
.tv_sec
,
1388 old_time_window
->time_width
.tv_nsec
);
1390 g_info("New time window HOOK : %lu, %lu to %lu, %lu",
1391 new_time_window
->start_time
.tv_sec
,
1392 new_time_window
->start_time
.tv_nsec
,
1393 new_time_window
->time_width
.tv_sec
,
1394 new_time_window
->time_width
.tv_nsec
);
1396 if( new_time_window
->time_width
.tv_sec
== old_time_window
->time_width
.tv_sec
1397 && new_time_window
->time_width
.tv_nsec
== old_time_window
->time_width
.tv_nsec
)
1399 /* Same scale (scrolling) */
1400 g_info("scrolling");
1401 LttTime
*ns
= &new_time_window
->start_time
;
1402 LttTime
*os
= &old_time_window
->start_time
;
1403 LttTime old_end
= old_time_window
->end_time
;
1404 LttTime new_end
= new_time_window
->end_time
;
1406 //if(ns<os+w && os+w<ns+w)
1407 //if(ns<old_end && os<ns)
1408 if(ltt_time_compare(*ns
, old_end
) == -1
1409 && ltt_time_compare(*os
, *ns
) == -1)
1411 g_info("scrolling near right");
1412 /* Scroll right, keep right part of the screen */
1414 guint width
= control_flow_data
->drawing
->width
;
1415 convert_time_to_pixels(
1421 /* Copy old data to new location */
1422 copy_pixmap_region(process_list
,
1424 control_flow_data
->drawing
->drawing_area
->style
->black_gc
,
1428 control_flow_data
->drawing
->width
-x
+SAFETY
, -1);
1430 if(drawing
->damage_begin
== drawing
->damage_end
)
1431 drawing
->damage_begin
= control_flow_data
->drawing
->width
-x
;
1433 drawing
->damage_begin
= 0;
1435 drawing
->damage_end
= control_flow_data
->drawing
->width
;
1437 /* Clear the data request background, but not SAFETY */
1438 rectangle_pixmap(process_list
,
1439 control_flow_data
->drawing
->drawing_area
->style
->black_gc
,
1441 drawing
->damage_begin
+SAFETY
, 0,
1442 drawing
->damage_end
- drawing
->damage_begin
, // do not overlap
1444 gtk_widget_queue_draw(drawing
->drawing_area
);
1445 //gtk_widget_queue_draw_area (drawing->drawing_area,
1447 // control_flow_data->drawing->width,
1448 // control_flow_data->drawing->height);
1450 /* Get new data for the rest. */
1451 drawing_data_request(control_flow_data
->drawing
,
1452 drawing
->damage_begin
, 0,
1453 drawing
->damage_end
- drawing
->damage_begin
,
1454 control_flow_data
->drawing
->height
);
1457 //if(ns<os && os<ns+w)
1458 //if(ns<os && os<new_end)
1459 if(ltt_time_compare(*ns
,*os
) == -1
1460 && ltt_time_compare(*os
,new_end
) == -1)
1462 g_info("scrolling near left");
1463 /* Scroll left, keep left part of the screen */
1465 guint width
= control_flow_data
->drawing
->width
;
1466 convert_time_to_pixels(
1472 /* Copy old data to new location */
1473 copy_pixmap_region (process_list
,
1475 control_flow_data
->drawing
->drawing_area
->style
->black_gc
,
1481 if(drawing
->damage_begin
== drawing
->damage_end
)
1482 drawing
->damage_end
= x
;
1484 drawing
->damage_end
=
1485 control_flow_data
->drawing
->width
;
1487 drawing
->damage_begin
= 0;
1489 rectangle_pixmap (process_list
,
1490 control_flow_data
->drawing
->drawing_area
->style
->black_gc
,
1492 drawing
->damage_begin
, 0,
1493 drawing
->damage_end
- drawing
->damage_begin
, // do not overlap
1496 gtk_widget_queue_draw(drawing
->drawing_area
);
1497 //gtk_widget_queue_draw_area (drawing->drawing_area,
1499 // control_flow_data->drawing->width,
1500 // control_flow_data->drawing->height);
1503 /* Get new data for the rest. */
1504 drawing_data_request(control_flow_data
->drawing
,
1505 drawing
->damage_begin
, 0,
1506 drawing
->damage_end
- drawing
->damage_begin
,
1507 control_flow_data
->drawing
->height
);
1510 if(ltt_time_compare(*ns
,*os
) == 0)
1512 g_info("not scrolling");
1514 g_info("scrolling far");
1515 /* Cannot reuse any part of the screen : far jump */
1518 rectangle_pixmap (process_list
,
1519 control_flow_data
->drawing
->drawing_area
->style
->black_gc
,
1522 control_flow_data
->drawing
->width
+SAFETY
, // do not overlap
1525 //gtk_widget_queue_draw_area (drawing->drawing_area,
1527 // control_flow_data->drawing->width,
1528 // control_flow_data->drawing->height);
1529 gtk_widget_queue_draw(drawing
->drawing_area
);
1531 drawing
->damage_begin
= 0;
1532 drawing
->damage_end
= control_flow_data
->drawing
->width
;
1534 drawing_data_request(control_flow_data
->drawing
,
1536 control_flow_data
->drawing
->width
,
1537 control_flow_data
->drawing
->height
);
1543 /* Different scale (zoom) */
1546 rectangle_pixmap (process_list
,
1547 control_flow_data
->drawing
->drawing_area
->style
->black_gc
,
1550 control_flow_data
->drawing
->width
+SAFETY
, // do not overlap
1553 //gtk_widget_queue_draw_area (drawing->drawing_area,
1555 // control_flow_data->drawing->width,
1556 // control_flow_data->drawing->height);
1557 gtk_widget_queue_draw(drawing
->drawing_area
);
1559 drawing
->damage_begin
= 0;
1560 drawing
->damage_end
= control_flow_data
->drawing
->width
;
1562 drawing_data_request(control_flow_data
->drawing
,
1564 control_flow_data
->drawing
->width
,
1565 control_flow_data
->drawing
->height
);
1568 /* Update directly when scrolling */
1569 gdk_window_process_updates(control_flow_data
->drawing
->drawing_area
->window
,
1575 gint
traceset_notify(void *hook_data
, void *call_data
)
1577 ControlFlowData
*control_flow_data
= (ControlFlowData
*) hook_data
;
1578 Drawing_t
*drawing
= control_flow_data
->drawing
;
1580 if(unlikely(drawing
->gc
== NULL
)) {
1583 if(drawing
->dotted_gc
== NULL
) {
1587 drawing_clear(control_flow_data
->drawing
);
1588 processlist_clear(control_flow_data
->process_list
);
1589 gtk_widget_set_size_request(
1590 control_flow_data
->drawing
->drawing_area
,
1591 -1, processlist_get_height(control_flow_data
->process_list
));
1592 redraw_notify(control_flow_data
, NULL
);
1594 request_background_data(control_flow_data
);
1599 gint
redraw_notify(void *hook_data
, void *call_data
)
1601 ControlFlowData
*control_flow_data
= (ControlFlowData
*) hook_data
;
1602 Drawing_t
*drawing
= control_flow_data
->drawing
;
1603 GtkWidget
*widget
= drawing
->drawing_area
;
1605 drawing
->damage_begin
= 0;
1606 drawing
->damage_end
= drawing
->width
;
1608 /* fun feature, to be separated someday... */
1609 drawing_clear(control_flow_data
->drawing
);
1610 processlist_clear(control_flow_data
->process_list
);
1611 gtk_widget_set_size_request(
1612 control_flow_data
->drawing
->drawing_area
,
1613 -1, processlist_get_height(control_flow_data
->process_list
));
1615 rectangle_pixmap (control_flow_data
->process_list
,
1616 widget
->style
->black_gc
,
1619 drawing
->alloc_width
,
1622 gtk_widget_queue_draw(drawing
->drawing_area
);
1624 if(drawing
->damage_begin
< drawing
->damage_end
)
1626 drawing_data_request(drawing
,
1627 drawing
->damage_begin
,
1629 drawing
->damage_end
-drawing
->damage_begin
,
1633 //gtk_widget_queue_draw_area(drawing->drawing_area,
1636 // drawing->height);
1642 gint
continue_notify(void *hook_data
, void *call_data
)
1644 ControlFlowData
*control_flow_data
= (ControlFlowData
*) hook_data
;
1645 Drawing_t
*drawing
= control_flow_data
->drawing
;
1647 //g_assert(widget->allocation.width == drawing->damage_end);
1649 if(drawing
->damage_begin
< drawing
->damage_end
)
1651 drawing_data_request(drawing
,
1652 drawing
->damage_begin
,
1654 drawing
->damage_end
-drawing
->damage_begin
,
1662 gint
update_current_time_hook(void *hook_data
, void *call_data
)
1665 ControlFlowData
*control_flow_data
= (ControlFlowData
*)hook_data
;
1667 LttTime current_time
= *((LttTime
*)call_data
);
1669 TimeWindow time_window
=
1670 lttvwindow_get_time_window(control_flow_data
->tab
);
1672 LttTime time_begin
= time_window
.start_time
;
1673 LttTime width
= time_window
.time_width
;
1676 guint64 time_ll
= ltt_time_to_uint64(width
);
1677 time_ll
= time_ll
>> 1; /* divide by two */
1678 half_width
= ltt_time_from_uint64(time_ll
);
1680 LttTime time_end
= ltt_time_add(time_begin
, width
);
1682 LttvTraceset
* ts
= lttvwindow_get_traceset(control_flow_data
->tab
);
1684 TimeInterval time_span
= lttv_traceset_get_time_span_real(ts
);
1685 LttTime trace_start
= time_span
.start_time
;
1686 LttTime trace_end
= time_span
.end_time
;
1688 g_info("New current time HOOK : %lu, %lu", current_time
.tv_sec
,
1689 current_time
.tv_nsec
);
1693 /* If current time is inside time interval, just move the highlight
1696 /* Else, we have to change the time interval. We have to tell it
1697 * to the main window. */
1698 /* The time interval change will take care of placing the current
1699 * time at the center of the visible area, or nearest possible if we are
1700 * at one end of the trace. */
1703 if(ltt_time_compare(current_time
, time_begin
) < 0)
1705 TimeWindow new_time_window
;
1707 if(ltt_time_compare(current_time
,
1708 ltt_time_add(trace_start
,half_width
)) < 0)
1709 time_begin
= trace_start
;
1711 time_begin
= ltt_time_sub(current_time
,half_width
);
1713 new_time_window
.start_time
= time_begin
;
1714 new_time_window
.time_width
= width
;
1715 new_time_window
.time_width_double
= ltt_time_to_double(width
);
1716 new_time_window
.end_time
= ltt_time_add(time_begin
, width
);
1718 lttvwindow_report_time_window(control_flow_data
->tab
, new_time_window
);
1720 else if(ltt_time_compare(current_time
, time_end
) > 0)
1722 TimeWindow new_time_window
;
1724 if(ltt_time_compare(current_time
, ltt_time_sub(trace_end
, half_width
)) > 0)
1725 time_begin
= ltt_time_sub(trace_end
,width
);
1727 time_begin
= ltt_time_sub(current_time
,half_width
);
1729 new_time_window
.start_time
= time_begin
;
1730 new_time_window
.time_width
= width
;
1731 new_time_window
.time_width_double
= ltt_time_to_double(width
);
1732 new_time_window
.end_time
= ltt_time_add(time_begin
, width
);
1734 lttvwindow_report_time_window(control_flow_data
->tab
, new_time_window
);
1737 gtk_widget_queue_draw(control_flow_data
->drawing
->drawing_area
);
1739 /* Update directly when scrolling */
1740 gdk_window_process_updates(control_flow_data
->drawing
->drawing_area
->window
,
1747 typedef struct _ClosureData
{
1748 EventsRequest
*events_request
;
1754 void draw_closure(gpointer key
, gpointer value
, gpointer user_data
)
1757 ProcessInfo
*process_info
= (ProcessInfo
*)key
;
1758 HashedProcessData
*hashed_process_data
= (HashedProcessData
*)value
;
1759 ClosureData
*closure_data
= (ClosureData
*)user_data
;
1761 EventsRequest
*events_request
= closure_data
->events_request
;
1762 ControlFlowData
*control_flow_data
= events_request
->viewer_data
;
1763 LttvTraceset
*ts
= lttvwindow_get_traceset(control_flow_data
->tab
);
1766 LttTime evtime
= closure_data
->end_time
;
1768 gboolean dodraw
= TRUE
;
1771 /* For the process */
1772 /* First, check if the current process is in the state computation
1773 * process list. If it is there, that means we must add it right now and
1774 * draw items from the beginning of the read for it. If it is not
1775 * present, it's a new process and it was not present : it will
1776 * be added after the state update. */
1778 g_assert(lttv_traceset_number(tsc
->ts
) > 0);
1779 #endif //EXTRA_CHECK
1780 //TODO Fdeslauriers 2012-07-17: adapt for multiple traces
1781 LttvTrace
*trace
= lttv_traceset_get(ts
,0);
1782 LttvTraceState
*trace_state
= trace
->state
;
1785 //FIXME : optimize data structures.
1786 LttvTracefileState
*tfs
;
1787 LttvTracefileContext
*tfc
;
1789 for(i
=0;i
<tc
->tracefiles
->len
;i
++) {
1790 tfc
= g_array_index(tc
->tracefiles
, LttvTracefileContext
*, i
);
1791 if(ltt_tracefile_name(tfc
->tf
) == LTT_NAME_CPU
1792 && tfs
->cpu
== process_info
->cpu
)
1796 g_assert(i
<tc
->tracefiles
->len
);
1797 tfs
= LTTV_TRACEFILE_STATE(tfc
);
1799 // LttvTracefileState *tfs =ts
1800 // (LttvTracefileState*)tsc->traces[process_info->trace_num]->
1801 // tracefiles[process_info->cpu];
1803 LttvProcessState
*process
;
1804 process
= lttv_state_find_process(trace_state
, process_info
->cpu
,
1807 if(unlikely(process
!= NULL
)) {
1808 #ifdef BABEL_CLEANUP
1809 LttvFilter
*filter
= control_flow_data
->filter
;
1810 if(filter
!= NULL
&& filter
->head
!= NULL
)
1811 if(!lttv_filter_tree_parse(filter
->head
,NULL
,NULL
,
1812 tc
->t
,NULL
,process
,tc
))
1814 #endif //babel_cleanup
1815 /* Only draw for processes that are currently in the trace states */
1818 /* Should be alike when background info is ready */
1819 if(control_flow_data
->background_info_waiting
==0)
1820 g_assert(ltt_time_compare(process
->creation_time
,
1821 process_info
->birth
) == 0);
1822 #endif //EXTRA_CHECK
1824 /* Now, the process is in the state hash and our own process hash.
1825 * We definitely can draw the items related to the ending state.
1828 if(unlikely(ltt_time_compare(hashed_process_data
->next_good_time
,
1831 TimeWindow time_window
=
1832 lttvwindow_get_time_window(control_flow_data
->tab
);
1835 if(ltt_time_compare(evtime
, time_window
.start_time
) == -1
1836 || ltt_time_compare(evtime
, time_window
.end_time
) == 1)
1838 #endif //EXTRA_CHECK
1839 Drawing_t
*drawing
= control_flow_data
->drawing
;
1840 guint width
= drawing
->width
;
1842 guint x
= closure_data
->x_end
;
1844 DrawContext draw_context
;
1846 init_drawing_context(&draw_context
,
1847 hashed_process_data
,
1852 /* Jump over draw if we are at the same x position */
1853 if(x
== hashed_process_data
->x
.over
)
1857 draw_context
.drawinfo
.start
.x
= hashed_process_data
->x
.over
;
1859 PropertiesLine prop_line
= prepare_execmode_line(process
);
1860 draw_line((void*)&prop_line
, (void*)&draw_context
);
1862 hashed_process_data
->x
.over
= x
;
1866 if(unlikely(x
== hashed_process_data
->x
.middle
&&
1867 hashed_process_data
->x
.middle_used
)) {
1868 #if 0 /* do not mark closure : not missing information */
1869 if(hashed_process_data
->x
.middle_marked
== FALSE
) {
1870 /* Draw collision indicator */
1871 gdk_gc_set_foreground(drawing
->gc
, &drawing_colors
[COL_WHITE
]);
1872 gdk_draw_point(drawing
->pixmap
,
1876 hashed_process_data
->x
.middle_marked
= TRUE
;
1881 draw_context
.drawinfo
.start
.x
= hashed_process_data
->x
.middle
;
1884 PropertiesLine prop_line
= prepare_s_e_line(process
);
1885 draw_line((void*)&prop_line
, (void*)&draw_context
);
1888 /* become the last x position */
1889 if(likely(x
!= hashed_process_data
->x
.middle
)) {
1890 hashed_process_data
->x
.middle
= x
;
1891 /* but don't use the pixel */
1892 hashed_process_data
->x
.middle_used
= FALSE
;
1894 /* Calculate the next good time */
1895 convert_pixels_to_time(width
, x
+1, time_window
,
1896 &hashed_process_data
->next_good_time
);
1905 int before_chunk(void *hook_data
, void *call_data
)
1908 EventsRequest
*events_request
= (EventsRequest
*)hook_data
;
1909 LttvTraceset
*ts
= (LttvTraceset
*)call_data
;
1911 /* Desactivate sort */
1912 gtk_tree_sortable_set_sort_column_id(
1913 GTK_TREE_SORTABLE(cfd
->process_list
->list_store
),
1915 GTK_SORT_ASCENDING
);
1917 drawing_chunk_begin(events_request
, ts
);
1922 int before_request(void *hook_data
, void *call_data
)
1925 EventsRequest
*events_request
= (EventsRequest
*)hook_data
;
1927 drawing_data_request_begin(events_request
);
1934 void draw_closing_lines(ControlFlowData
*control_flow_data
,
1935 EventsRequest
* events_request
)
1937 ProcessList
*process_list
= control_flow_data
->process_list
;
1940 ClosureData closure_data
;
1941 closure_data
.events_request
= events_request
;
1942 closure_data
.end_time
= events_request
->end_time
;
1944 TimeWindow time_window
=
1945 lttvwindow_get_time_window(control_flow_data
->tab
);
1946 guint width
= control_flow_data
->drawing
->width
;
1947 convert_time_to_pixels(
1949 events_request
->end_time
,
1951 &closure_data
.x_end
);
1954 /* Draw last items */
1955 g_hash_table_foreach(process_list
->process_hash
, draw_closure
,
1956 (void*)&closure_data
);
1959 /* Request expose */
1960 drawing_request_expose(events_request
, events_request
->end_time
);
1964 * after request is necessary in addition of after chunk in order to draw
1965 * lines until the end of the screen. after chunk just draws lines until
1972 int after_request(void *hook_data
, void *call_data
)
1975 EventsRequest
*events_request
= (EventsRequest
*)hook_data
;
1976 ControlFlowData
*control_flow_data
= events_request
->viewer_data
;
1978 draw_closing_lines(control_flow_data
, events_request
);
1988 int after_chunk(void *hook_data
, void *call_data
)
1991 EventsRequest
*events_request
= (EventsRequest
*)hook_data
;
1992 ControlFlowData
*control_flow_data
= events_request
->viewer_data
;
1993 LttvTraceset
*ts
= (LttvTraceset
*)call_data
;
1996 ProcessList
*process_list
= control_flow_data
->process_list
;
1998 guint nb_trace
= lttv_traceset_number(ts
);
2000 /* Only execute when called for the first trace's events request */
2001 if(!process_list
->current_hash_data
)
2004 for(i
= 0 ; i
< nb_trace
; i
++) {
2005 g_free(process_list
->current_hash_data
[i
]);
2007 g_free(process_list
->current_hash_data
);
2008 process_list
->current_hash_data
= NULL
;
2010 draw_closing_lines(control_flow_data
, events_request
);
2015 /* after_statedump_end
2017 * @param hook_data ControlFlowData structure of the viewer.
2018 * @param call_data Event context.
2020 * This function adds items to be drawn in a queue for each process.
2023 int before_statedump_end(void *hook_data
, void *call_data
)
2027 event
= (LttvEvent
*) call_data
;
2029 if (strcmp(lttv_traceset_get_name_from_event(event
),"lttng_statedump_end") != 0)
2032 ControlFlowData
*control_flow_data
= (ControlFlowData
*) hook_data
;
2035 LttvTraceState
*ts
= event
->state
;
2038 ProcessList
*process_list
= control_flow_data
->process_list
;
2040 #ifdef BABEL_CLEANUP
2041 LttvFilter
*filter
= control_flow_data
->filter
;
2042 if(filter
!= NULL
&& filter
->head
!= NULL
)
2043 if(!lttv_filter_tree_parse(filter
->head
,e
,tfc
->tf
,
2044 tfc
->t_context
->t
,tfc
,NULL
,NULL
))
2048 LttTime evtime
= lttv_event_get_timestamp(event
);
2050 ClosureData closure_data
;
2051 //TODO ybrosseau 2013-03-27: Fake and event_request.
2052 // We need to change the API of drawing_request_expose to ask
2053 // For and control flow data only.
2054 EventsRequest events_request
;
2055 events_request
.viewer_data
= control_flow_data
;
2056 closure_data
.events_request
= &events_request
;
2057 closure_data
.end_time
= evtime
;
2059 TimeWindow time_window
=
2060 lttvwindow_get_time_window(control_flow_data
->tab
);
2061 guint width
= control_flow_data
->drawing
->width
;
2062 convert_time_to_pixels(
2066 &closure_data
.x_end
);
2068 /* Draw last items */
2069 g_hash_table_foreach(process_list
->process_hash
, draw_closure
,
2070 (void*)&closure_data
);
2073 /* Reactivate sort */
2074 gtk_tree_sortable_set_sort_column_id(
2075 GTK_TREE_SORTABLE(control_flow_data
->process_list
->list_store
),
2076 GTK_TREE_SORTABLE_DEFAULT_SORT_COLUMN_ID
,
2077 GTK_SORT_ASCENDING
);
2079 update_index_to_pixmap(control_flow_data
->process_list
);
2080 /* Request a full expose : drawing scrambled */
2081 gtk_widget_queue_draw(control_flow_data
->drawing
->drawing_area
);
2083 /* Request expose (updates damages zone also) */
2084 drawing_request_expose(&events_request
, evtime
);