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"
76 #define MAX_PATH_LEN 256
80 typedef struct _ProcessAddClosure
{
85 static void process_add(gpointer key
,
89 LttvProcessState
*process
= (LttvProcessState
*)value
;
90 ProcessAddClosure
*closure
= (ProcessAddClosure
*)user_data
;
91 ControlFlowData
*control_flow_data
= closure
->cfd
;
92 guint trace_num
= closure
->trace_num
;
94 /* Add process to process list (if not present) */
97 guint y
= 0, height
= 0, pl_height
= 0;
99 ProcessList
*process_list
= control_flow_data
->process_list
;
102 birth
= process
->creation_time
;
103 const gchar
*name
= g_quark_to_string(process
->name
);
104 HashedProcessData
*hashed_process_data
= NULL
;
106 if(processlist_get_process_pixels(process_list
,
112 &hashed_process_data
) == 1)
114 /* Process not present */
115 processlist_add(process_list
,
121 &hashed_process_data
);
122 processlist_get_process_pixels(process_list
,
128 &hashed_process_data
);
129 drawing_insert_square( control_flow_data
->drawing
, y
, height
);
135 /* Action to do when background computation completed.
137 * Wait for all the awaited computations to be over.
140 gint
background_ready(void *hook_data
, void *call_data
)
142 ControlFlowData
*control_flow_data
= (ControlFlowData
*)hook_data
;
143 LttvTrace
*trace
= (LttvTrace
*)call_data
;
144 LttvTracesetContext
*tsc
=
145 lttvwindow_get_traceset_context(control_flow_data
->tab
);
147 control_flow_data
->background_info_waiting
--;
149 if(control_flow_data
->background_info_waiting
== 0) {
150 g_debug("control flow viewer : background computation data ready.");
152 drawing_clear(control_flow_data
->drawing
);
153 processlist_clear(control_flow_data
->process_list
);
154 redraw_notify(control_flow_data
, NULL
);
161 /* Request background computation. Verify if it is in progress or ready first.
162 * Only for each trace in the tab's traceset.
164 void request_background_data(ControlFlowData
*control_flow_data
)
166 LttvTracesetContext
* tsc
=
167 lttvwindow_get_traceset_context(control_flow_data
->tab
);
168 gint num_traces
= lttv_traceset_number(tsc
->ts
);
172 LttvHooks
*background_ready_hook
=
174 lttv_hooks_add(background_ready_hook
, background_ready
, control_flow_data
,
176 control_flow_data
->background_info_waiting
= 0;
178 for(i
=0;i
<num_traces
;i
++) {
179 trace
= lttv_traceset_get(tsc
->ts
, i
);
181 if(lttvwindowtraces_get_ready(g_quark_from_string("state"),trace
)==FALSE
) {
183 if(lttvwindowtraces_get_in_progress(g_quark_from_string("state"),
185 /* We first remove requests that could have been done for the same
186 * information. Happens when two viewers ask for it before servicing
189 lttvwindowtraces_background_request_remove(trace
, "state");
190 lttvwindowtraces_background_request_queue(trace
,
192 lttvwindowtraces_background_notify_queue(control_flow_data
,
196 background_ready_hook
);
197 control_flow_data
->background_info_waiting
++;
198 } else { /* in progress */
200 lttvwindowtraces_background_notify_current(control_flow_data
,
204 background_ready_hook
);
205 control_flow_data
->background_info_waiting
++;
208 /* Data ready. Be its nature, this viewer doesn't need to have
209 * its data ready hook called htere, because a background
210 * request is always linked with a redraw.
216 lttv_hooks_destroy(background_ready_hook
);
223 * Event Viewer's constructor hook
225 * This constructor is given as a parameter to the menuitem and toolbar button
226 * registration. It creates the list.
227 * @param tab A pointer to the parent tab.
228 * @return The widget created.
231 h_guicontrolflow(Tab
*tab
)
233 g_info("h_guicontrolflow, %p", tab
);
234 ControlFlowData
*control_flow_data
= guicontrolflow() ;
236 control_flow_data
->tab
= tab
;
238 //g_debug("time width2 : %u",time_window->time_width);
239 // Unreg done in the GuiControlFlow_Destructor
240 lttvwindow_register_traceset_notify(tab
,
244 lttvwindow_register_time_window_notify(tab
,
245 update_time_window_hook
,
247 lttvwindow_register_current_time_notify(tab
,
248 update_current_time_hook
,
250 lttvwindow_register_redraw_notify(tab
,
253 lttvwindow_register_continue_notify(tab
,
256 request_background_data(control_flow_data
);
259 return guicontrolflow_get_widget(control_flow_data
) ;
263 int event_selected_hook(void *hook_data
, void *call_data
)
265 ControlFlowData
*control_flow_data
= (ControlFlowData
*) hook_data
;
266 guint
*event_number
= (guint
*) call_data
;
268 g_debug("DEBUG : event selected by main window : %u", *event_number
);
272 /* Function that selects the color of status&exemode line */
273 static inline PropertiesLine
prepare_s_e_line(LttvProcessState
*process
)
275 PropertiesLine prop_line
;
276 prop_line
.line_width
= 2;
277 prop_line
.style
= GDK_LINE_SOLID
;
278 prop_line
.y
= MIDDLE
;
279 //GdkColormap *colormap = gdk_colormap_get_system();
281 g_debug("prepare_status_line for state : %s",
282 g_quark_to_string(process
->state
->s
));
284 if(process
->state
->s
== LTTV_STATE_RUN
) {
285 if(process
->state
->t
== LTTV_STATE_USER_MODE
)
286 prop_line
.color
= drawing_colors
[COL_RUN_USER_MODE
];
287 else if(process
->state
->t
== LTTV_STATE_SYSCALL
)
288 prop_line
.color
= drawing_colors
[COL_RUN_SYSCALL
];
289 else if(process
->state
->t
== LTTV_STATE_TRAP
)
290 prop_line
.color
= drawing_colors
[COL_RUN_TRAP
];
291 else if(process
->state
->t
== LTTV_STATE_IRQ
)
292 prop_line
.color
= drawing_colors
[COL_RUN_IRQ
];
293 else if(process
->state
->t
== LTTV_STATE_MODE_UNKNOWN
)
294 prop_line
.color
= drawing_colors
[COL_MODE_UNKNOWN
];
296 g_assert(FALSE
); /* RUNNING MODE UNKNOWN */
297 } else if(process
->state
->s
== LTTV_STATE_WAIT
) {
298 /* We don't show if we wait while in user mode, trap, irq or syscall */
299 prop_line
.color
= drawing_colors
[COL_WAIT
];
300 } else if(process
->state
->s
== LTTV_STATE_WAIT_CPU
) {
301 /* We don't show if we wait for CPU while in user mode, trap, irq
303 prop_line
.color
= drawing_colors
[COL_WAIT_CPU
];
304 } else if(process
->state
->s
== LTTV_STATE_ZOMBIE
) {
305 prop_line
.color
= drawing_colors
[COL_ZOMBIE
];
306 } else if(process
->state
->s
== LTTV_STATE_WAIT_FORK
) {
307 prop_line
.color
= drawing_colors
[COL_WAIT_FORK
];
308 } else if(process
->state
->s
== LTTV_STATE_EXIT
) {
309 prop_line
.color
= drawing_colors
[COL_EXIT
];
310 } else if(process
->state
->s
== LTTV_STATE_UNNAMED
) {
311 prop_line
.color
= drawing_colors
[COL_UNNAMED
];
313 g_assert(FALSE
); /* UNKNOWN STATE */
320 static inline PropertiesLine
prepare_status_line(LttvProcessState
*process
)
322 PropertiesLine prop_line
;
323 prop_line
.line_width
= 2;
324 prop_line
.style
= GDK_LINE_SOLID
;
325 prop_line
.y
= MIDDLE
;
326 //GdkColormap *colormap = gdk_colormap_get_system();
328 g_debug("prepare_status_line for state : %s",
329 g_quark_to_string(process
->state
->s
));
331 /* color of line : status of the process */
332 if(process
->state
->s
== LTTV_STATE_UNNAMED
)
333 prop_line
.color
= drawing_colors
[COL_WHITE
];
334 else if(process
->state
->s
== LTTV_STATE_WAIT_FORK
)
335 prop_line
.color
= drawing_colors
[COL_WAIT_FORK
];
336 else if(process
->state
->s
== LTTV_STATE_WAIT_CPU
)
337 prop_line
.color
= drawing_colors
[COL_WAIT_CPU
];
338 else if(process
->state
->s
== LTTV_STATE_EXIT
)
339 prop_line
.color
= drawing_colors
[COL_EXIT
];
340 else if(process
->state
->s
== LTTV_STATE_ZOMBIE
)
341 prop_line
.color
= drawing_colors
[COL_ZOMBIE
];
342 else if(process
->state
->s
== LTTV_STATE_WAIT
)
343 prop_line
.color
= drawing_colors
[COL_WAIT
];
344 else if(process
->state
->s
== LTTV_STATE_RUN
)
345 prop_line
.color
= drawing_colors
[COL_RUN
];
347 prop_line
.color
= drawing_colors
[COL_WHITE
];
349 //gdk_colormap_alloc_color(colormap,
360 /* before_schedchange_hook
362 * This function basically draw lines and icons. Two types of lines are drawn :
363 * one small (3 pixels?) representing the state of the process and the second
364 * type is thicker (10 pixels?) representing on which CPU a process is running
365 * (and this only in running state).
367 * Extremums of the lines :
368 * x_min : time of the last event context for this process kept in memory.
369 * x_max : time of the current event.
370 * y : middle of the process in the process list. The process is found in the
371 * list, therefore is it's position in pixels.
373 * The choice of lines'color is defined by the context of the last event for this
378 int before_schedchange_hook(void *hook_data
, void *call_data
)
380 EventsRequest
*events_request
= (EventsRequest
*)hook_data
;
381 ControlFlowData
*control_flow_data
= events_request
->viewer_data
;
382 Drawing_t
*drawing
= control_flow_data
->drawing
;
384 LttvTracefileContext
*tfc
= (LttvTracefileContext
*)call_data
;
386 LttvTracefileState
*tfs
= (LttvTracefileState
*)call_data
;
387 LttvTraceState
*ts
=(LttvTraceState
*)((LttvTracefileContext
*)tfs
)->t_context
;
392 LttTime evtime
= ltt_event_time(e
);
394 guint width
= drawing
->width
;
396 /* we are in a schedchange, before the state update. We must draw the
397 * items corresponding to the state before it changes : now is the right
404 LttField
*f
= ltt_event_field(e
);
406 element
= ltt_field_member(f
,0);
407 pid_out
= ltt_event_get_long_unsigned(e
,element
);
408 element
= ltt_field_member(f
,1);
409 pid_in
= ltt_event_get_long_unsigned(e
,element
);
410 g_debug("out : %u in : %u", pid_out
, pid_in
);
414 /* For the pid_out */
415 /* First, check if the current process is in the state computation
416 * process list. If it is there, that means we must add it right now and
417 * draw items from the beginning of the read for it. If it is not
418 * present, it's a new process and it was not present : it will
419 * be added after the state update. */
420 LttvProcessState
*process
;
421 /* unknown state, bad current pid */
422 if(tfs
->process
->pid
!= pid_out
)
423 process
= lttv_state_find_process(tfs
, pid_out
);
425 process
= tfs
->process
;
427 if(process
!= NULL
) {
428 /* Well, the process_out existed : we must get it in the process hash
429 * or add it, and draw its items.
431 /* Add process to process list (if not present) */
432 guint y
= 0, height
= 0, pl_height
= 0;
433 HashedProcessData
*hashed_process_data
= NULL
;
434 ProcessList
*process_list
= control_flow_data
->process_list
;
435 LttTime birth
= process
->creation_time
;
437 hashed_process_data
= processlist_get_process_data(process_list
,
439 process
->last_cpu_index
,
441 tfc
->t_context
->index
);
442 if(hashed_process_data
== NULL
)
444 g_assert(pid_out
== 0 || pid_out
!= process
->ppid
);
445 const gchar
*name
= g_quark_to_string(process
->name
);
446 /* Process not present */
447 ProcessInfo
*process_info
;
448 processlist_add(process_list
,
450 process
->last_cpu_index
,
453 tfc
->t_context
->index
,
457 &hashed_process_data
);
458 processlist_get_pixels_from_data(process_list
,
462 drawing_insert_square( drawing
, y
, height
);
465 /* Now, the process is in the state hash and our own process hash.
466 * We definitely can draw the items related to the ending state.
469 /* Check if the x position is unset. In can have been left unset by
470 * a draw closure from a after chunk hook. This should never happen,
471 * because it must be set by before chunk hook to the damage_begin
474 g_assert(hashed_process_data
->x
.middle
!= -1);
475 if(ltt_time_compare(hashed_process_data
->next_good_time
,
478 if(hashed_process_data
->x
.middle_marked
== FALSE
) {
479 processlist_get_pixels_from_data(process_list
,
484 TimeWindow time_window
=
485 lttvwindow_get_time_window(control_flow_data
->tab
);
487 if(ltt_time_compare(evtime
, time_window
.start_time
) == -1
488 || ltt_time_compare(evtime
, time_window
.end_time
) == 1)
493 convert_time_to_pixels(
499 /* Draw collision indicator */
500 gdk_gc_set_foreground(drawing
->gc
, &drawing_colors
[COL_WHITE
]);
501 gdk_draw_point(drawing
->pixmap
,
505 hashed_process_data
->x
.middle_marked
= TRUE
;
508 processlist_get_pixels_from_data(process_list
,
514 TimeWindow time_window
=
515 lttvwindow_get_time_window(control_flow_data
->tab
);
517 if(ltt_time_compare(evtime
, time_window
.start_time
) == -1
518 || ltt_time_compare(evtime
, time_window
.end_time
) == 1)
523 convert_time_to_pixels(
530 /* Jump over draw if we are at the same x position */
531 if(x
== hashed_process_data
->x
.middle
&&
532 hashed_process_data
->x
.middle_used
)
534 if(hashed_process_data
->x
.middle_marked
== FALSE
) {
535 /* Draw collision indicator */
536 gdk_gc_set_foreground(drawing
->gc
, &drawing_colors
[COL_WHITE
]);
537 gdk_draw_point(drawing
->pixmap
,
541 hashed_process_data
->x
.middle_marked
= TRUE
;
545 DrawContext draw_context
;
547 /* Now create the drawing context that will be used to draw
548 * items related to the last state. */
549 draw_context
.drawable
= drawing
->pixmap
;
550 draw_context
.gc
= drawing
->gc
;
551 draw_context
.pango_layout
= drawing
->pango_layout
;
552 draw_context
.drawinfo
.start
.x
= hashed_process_data
->x
.middle
;
553 draw_context
.drawinfo
.end
.x
= x
;
555 draw_context
.drawinfo
.y
.over
= y
+1;
556 draw_context
.drawinfo
.y
.middle
= y
+(height
/2);
557 draw_context
.drawinfo
.y
.under
= y
+height
;
559 draw_context
.drawinfo
.start
.offset
.over
= 0;
560 draw_context
.drawinfo
.start
.offset
.middle
= 0;
561 draw_context
.drawinfo
.start
.offset
.under
= 0;
562 draw_context
.drawinfo
.end
.offset
.over
= 0;
563 draw_context
.drawinfo
.end
.offset
.middle
= 0;
564 draw_context
.drawinfo
.end
.offset
.under
= 0;
568 PropertiesLine prop_line
= prepare_s_e_line(process
);
569 draw_line((void*)&prop_line
, (void*)&draw_context
);
572 /* become the last x position */
573 hashed_process_data
->x
.middle
= x
;
574 hashed_process_data
->x
.middle_used
= TRUE
;
575 hashed_process_data
->x
.middle_marked
= FALSE
;
577 /* Calculate the next good time */
578 convert_pixels_to_time(width
, x
+1, time_window
,
579 &hashed_process_data
->next_good_time
);
587 /* First, check if the current process is in the state computation
588 * process list. If it is there, that means we must add it right now and
589 * draw items from the beginning of the read for it. If it is not
590 * present, it's a new process and it was not present : it will
591 * be added after the state update. */
592 LttvProcessState
*process
;
593 process
= lttv_state_find_process(tfs
, pid_in
);
595 if(process
!= NULL
) {
596 /* Well, the process_out existed : we must get it in the process hash
597 * or add it, and draw its items.
599 /* Add process to process list (if not present) */
600 guint y
= 0, height
= 0, pl_height
= 0;
601 HashedProcessData
*hashed_process_data
= NULL
;
602 ProcessList
*process_list
= control_flow_data
->process_list
;
603 LttTime birth
= process
->creation_time
;
605 hashed_process_data
= processlist_get_process_data(process_list
,
607 process
->last_cpu_index
,
609 tfc
->t_context
->index
);
610 if(hashed_process_data
== NULL
)
612 g_assert(pid_in
== 0 || pid_in
!= process
->ppid
);
613 const gchar
*name
= g_quark_to_string(process
->name
);
614 /* Process not present */
615 ProcessInfo
*process_info
;
616 processlist_add(process_list
,
618 process
->last_cpu_index
,
621 tfc
->t_context
->index
,
625 &hashed_process_data
);
626 processlist_get_pixels_from_data(process_list
,
630 drawing_insert_square( drawing
, y
, height
);
632 //We could set the current process and hash here, but will be done
633 //by after schedchange hook
635 /* Now, the process is in the state hash and our own process hash.
636 * We definitely can draw the items related to the ending state.
639 /* Check if the x position is unset. In can have been left unset by
640 * a draw closure from a after chunk hook. This should never happen,
641 * because it must be set by before chunk hook to the damage_begin
644 g_assert(hashed_process_data
->x
.middle
!= -1);
646 if(ltt_time_compare(hashed_process_data
->next_good_time
,
649 if(hashed_process_data
->x
.middle_marked
== FALSE
) {
651 processlist_get_pixels_from_data(process_list
,
655 TimeWindow time_window
=
656 lttvwindow_get_time_window(control_flow_data
->tab
);
658 if(ltt_time_compare(evtime
, time_window
.start_time
) == -1
659 || ltt_time_compare(evtime
, time_window
.end_time
) == 1)
663 convert_time_to_pixels(
669 /* Draw collision indicator */
670 gdk_gc_set_foreground(drawing
->gc
, &drawing_colors
[COL_WHITE
]);
671 gdk_draw_point(drawing
->pixmap
,
675 hashed_process_data
->x
.middle_marked
= TRUE
;
678 processlist_get_pixels_from_data(process_list
,
682 TimeWindow time_window
=
683 lttvwindow_get_time_window(control_flow_data
->tab
);
685 if(ltt_time_compare(evtime
, time_window
.start_time
) == -1
686 || ltt_time_compare(evtime
, time_window
.end_time
) == 1)
691 convert_time_to_pixels(
698 /* Jump over draw if we are at the same x position */
699 if(x
== hashed_process_data
->x
.middle
&&
700 hashed_process_data
->x
.middle_used
)
702 if(hashed_process_data
->x
.middle_marked
== FALSE
) {
703 /* Draw collision indicator */
704 gdk_gc_set_foreground(drawing
->gc
, &drawing_colors
[COL_WHITE
]);
705 gdk_draw_point(drawing
->pixmap
,
709 hashed_process_data
->x
.middle_marked
= TRUE
;
713 DrawContext draw_context
;
715 /* Now create the drawing context that will be used to draw
716 * items related to the last state. */
717 draw_context
.drawable
= drawing
->pixmap
;
718 draw_context
.gc
= drawing
->gc
;
719 draw_context
.pango_layout
= drawing
->pango_layout
;
720 draw_context
.drawinfo
.start
.x
= hashed_process_data
->x
.middle
;
721 draw_context
.drawinfo
.end
.x
= x
;
723 draw_context
.drawinfo
.y
.over
= y
+1;
724 draw_context
.drawinfo
.y
.middle
= y
+(height
/2);
725 draw_context
.drawinfo
.y
.under
= y
+height
;
727 draw_context
.drawinfo
.start
.offset
.over
= 0;
728 draw_context
.drawinfo
.start
.offset
.middle
= 0;
729 draw_context
.drawinfo
.start
.offset
.under
= 0;
730 draw_context
.drawinfo
.end
.offset
.over
= 0;
731 draw_context
.drawinfo
.end
.offset
.middle
= 0;
732 draw_context
.drawinfo
.end
.offset
.under
= 0;
736 PropertiesLine prop_line
= prepare_s_e_line(process
);
737 draw_line((void*)&prop_line
, (void*)&draw_context
);
741 /* become the last x position */
742 hashed_process_data
->x
.middle
= x
;
743 hashed_process_data
->x
.middle_used
= TRUE
;
744 hashed_process_data
->x
.middle_marked
= FALSE
;
746 /* Calculate the next good time */
747 convert_pixels_to_time(width
, x
+1, time_window
,
748 &hashed_process_data
->next_good_time
);
757 EventsRequest
*events_request
= (EventsRequest
*)hook_data
;
758 ControlFlowData
*control_flow_data
=
759 (ControlFlowData
*)events_request
->viewer_data
;
760 Tab
*tab
= control_flow_data
->tab
;
762 LttvTracefileContext
*tfc
= (LttvTracefileContext
*)call_data
;
764 LttvTracefileState
*tfs
= (LttvTracefileState
*)call_data
;
765 LttvTraceState
*ts
=(LttvTraceState
*)LTTV_TRACEFILE_CONTEXT(tfs
)->t_context
;
770 LttTime evtime
= ltt_event_time(e
);
771 TimeWindow time_window
=
772 lttvwindow_get_time_window(tab
);
774 LttTime time_window
.end_time
= time_window
.time_window
.end_time
;
776 //if(time < time_beg || time > time_end) return;
777 if(ltt_time_compare(evtime
, time_window
.start_time
) == -1
778 || ltt_time_compare(evtime
, time_window
.end_time
) == 1)
781 if(strcmp(ltt_eventtype_name(ltt_event_eventtype(e
)),"schedchange") == 0)
783 g_debug("schedchange!");
785 /* Add process to process list (if not present) and get drawing "y" from
786 * process position */
787 guint pid_out
, pid_in
;
788 LttvProcessState
*process_out
, *process_in
;
790 guint y_in
= 0, y_out
= 0, height
= 0, pl_height
= 0;
792 ProcessList
*process_list
= control_flow_data
->process_list
;
795 LttField
*f
= ltt_event_field(e
);
797 element
= ltt_field_member(f
,0);
798 pid_out
= ltt_event_get_long_unsigned(e
,element
);
799 element
= ltt_field_member(f
,1);
800 pid_in
= ltt_event_get_long_unsigned(e
,element
);
801 g_debug("out : %u in : %u", pid_out
, pid_in
);
804 /* Find process pid_out in the list... */
805 process_out
= lttv_state_find_process(tfs
, pid_out
);
806 if(process_out
== NULL
) return 0;
807 g_debug("out : %s",g_quark_to_string(process_out
->state
->s
));
809 birth
= process_out
->creation_time
;
810 const gchar
*name
= g_quark_to_string(process_out
->name
);
811 HashedProcessData
*hashed_process_data_out
= NULL
;
813 if(processlist_get_process_pixels(process_list
,
816 tfc
->t_context
->index
,
819 &hashed_process_data_out
) == 1)
821 /* Process not present */
822 processlist_add(process_list
,
825 tfc
->t_context
->index
,
828 &hashed_process_data_out
);
829 g_assert(processlist_get_process_pixels(process_list
,
832 tfc
->t_context
->index
,
835 &hashed_process_data_out
)==0);
836 drawing_insert_square( control_flow_data
->drawing
, y_out
, height
);
840 /* Find process pid_in in the list... */
841 process_in
= lttv_state_find_process(tfs
, pid_in
);
842 if(process_in
== NULL
) return 0;
843 g_debug("in : %s",g_quark_to_string(process_in
->state
->s
));
845 birth
= process_in
->creation_time
;
846 name
= g_quark_to_string(process_in
->name
);
847 HashedProcessData
*hashed_process_data_in
= NULL
;
849 if(processlist_get_process_pixels(process_list
,
852 tfc
->t_context
->index
,
855 &hashed_process_data_in
) == 1)
857 /* Process not present */
858 processlist_add(process_list
,
861 tfc
->t_context
->index
,
864 &hashed_process_data_in
);
865 processlist_get_process_pixels(process_list
,
868 tfc
->t_context
->index
,
871 &hashed_process_data_in
);
873 drawing_insert_square( control_flow_data
->drawing
, y_in
, height
);
878 /* Find pixels corresponding to time of the event. If the time does
879 * not fit in the window, show a warning, not supposed to happend. */
881 guint width
= control_flow_data
->drawing
->width
;
883 LttTime time
= ltt_event_time(e
);
885 LttTime window_end
= time_window
.time_window
.end_time
;
887 convert_time_to_pixels(
892 //assert(x <= width);
894 /* draw what represents the event for outgoing process. */
896 DrawContext
*draw_context_out
= hashed_process_data_out
->draw_context
;
897 draw_context_out
->current
->modify_over
->x
= x
;
898 draw_context_out
->current
->modify_under
->x
= x
;
899 draw_context_out
->current
->modify_over
->y
= y_out
;
900 draw_context_out
->current
->modify_under
->y
= y_out
+(height
/2)+2;
901 draw_context_out
->drawable
= control_flow_data
->drawing
->pixmap
;
902 draw_context_out
->pango_layout
= control_flow_data
->drawing
->pango_layout
;
903 GtkWidget
*widget
= control_flow_data
->drawing
->drawing_area
;
904 //draw_context_out->gc = widget->style->fg_gc[GTK_WIDGET_STATE (widget)];
905 //draw_context_out->gc = gdk_gc_new(control_flow_data->drawing->pixmap);
906 //gdk_gc_copy(draw_context_out->gc, widget->style->black_gc);
907 //draw_context_out->gc = widget->style->black_gc;
909 //draw_arc((void*)&prop_arc, (void*)draw_context_out);
910 //test_draw_item(control_flow_data->drawing, control_flow_data->drawing->pixmap);
912 /* Draw the line/background of the out process */
913 if(draw_context_out
->previous
->middle
->x
== -1)
915 draw_context_out
->previous
->over
->x
=
916 control_flow_data
->drawing
->damage_begin
;
917 draw_context_out
->previous
->middle
->x
=
918 control_flow_data
->drawing
->damage_begin
;
919 draw_context_out
->previous
->under
->x
=
920 control_flow_data
->drawing
->damage_begin
;
922 g_debug("out middle x_beg : %u",control_flow_data
->drawing
->damage_begin
);
925 draw_context_out
->current
->middle
->x
= x
;
926 draw_context_out
->current
->over
->x
= x
;
927 draw_context_out
->current
->under
->x
= x
;
928 draw_context_out
->current
->middle
->y
= y_out
+ height
/2;
929 draw_context_out
->current
->over
->y
= y_out
;
930 draw_context_out
->current
->under
->y
= y_out
+ height
;
931 draw_context_out
->previous
->middle
->y
= y_out
+ height
/2;
932 draw_context_out
->previous
->over
->y
= y_out
;
933 draw_context_out
->previous
->under
->y
= y_out
+ height
;
935 draw_context_out
->drawable
= control_flow_data
->drawing
->pixmap
;
936 draw_context_out
->pango_layout
= control_flow_data
->drawing
->pango_layout
;
938 if(process_out
->state
->s
== LTTV_STATE_RUN
)
940 //draw_context_out->gc = gdk_gc_new(control_flow_data->drawing->pixmap);
941 //gdk_gc_copy(draw_context_out->gc, widget->style->black_gc);
942 draw_context_out
->gc
= control_flow_data
->drawing
->gc
;
944 PropertiesBG prop_bg
;
945 prop_bg
.color
= g_new(GdkColor
,1);
949 prop_bg
.color
->red
= 0x1515;
950 prop_bg
.color
->green
= 0x1515;
951 prop_bg
.color
->blue
= 0x8c8c;
954 prop_bg
.color
->red
= 0x4e4e;
955 prop_bg
.color
->green
= 0xa9a9;
956 prop_bg
.color
->blue
= 0xa4a4;
959 prop_bg
.color
->red
= 0x7a7a;
960 prop_bg
.color
->green
= 0x4a4a;
961 prop_bg
.color
->blue
= 0x8b8b;
964 prop_bg
.color
->red
= 0x8080;
965 prop_bg
.color
->green
= 0x7777;
966 prop_bg
.color
->blue
= 0x4747;
969 prop_bg
.color
->red
= 0xe7e7;
970 prop_bg
.color
->green
= 0xe7e7;
971 prop_bg
.color
->blue
= 0xe7e7;
974 g_debug("calling from draw_event");
975 draw_bg((void*)&prop_bg
, (void*)draw_context_out
);
976 g_free(prop_bg
.color
);
977 //gdk_gc_unref(draw_context_out->gc);
980 draw_context_out
->gc
= widget
->style
->black_gc
;
982 GdkColor colorfg_out
= { 0, 0xffff, 0x0000, 0x0000 };
983 GdkColor colorbg_out
= { 0, 0x0000, 0x0000, 0x0000 };
984 PropertiesText prop_text_out
;
985 prop_text_out
.foreground
= &colorfg_out
;
986 prop_text_out
.background
= &colorbg_out
;
987 prop_text_out
.size
= 6;
988 prop_text_out
.position
= OVER
;
990 /* color of text : status of the process */
991 if(process_out
->state
->s
== LTTV_STATE_UNNAMED
)
993 prop_text_out
.foreground
->red
= 0xffff;
994 prop_text_out
.foreground
->green
= 0xffff;
995 prop_text_out
.foreground
->blue
= 0xffff;
997 else if(process_out
->state
->s
== LTTV_STATE_WAIT_FORK
)
999 prop_text_out
.foreground
->red
= 0x0fff;
1000 prop_text_out
.foreground
->green
= 0xffff;
1001 prop_text_out
.foreground
->blue
= 0xfff0;
1003 else if(process_out
->state
->s
== LTTV_STATE_WAIT_CPU
)
1005 prop_text_out
.foreground
->red
= 0xffff;
1006 prop_text_out
.foreground
->green
= 0xffff;
1007 prop_text_out
.foreground
->blue
= 0x0000;
1009 else if(process_out
->state
->s
== LTTV_STATE_ZOMBIE
)
1011 prop_text_out
.foreground
->red
= 0xffff;
1012 prop_text_out
.foreground
->green
= 0x0000;
1013 prop_text_out
.foreground
->blue
= 0xffff;
1015 else if(process_out
->state
->s
== LTTV_STATE_WAIT
)
1017 prop_text_out
.foreground
->red
= 0xffff;
1018 prop_text_out
.foreground
->green
= 0x0000;
1019 prop_text_out
.foreground
->blue
= 0x0000;
1021 else if(process_out
->state
->s
== LTTV_STATE_RUN
)
1023 prop_text_out
.foreground
->red
= 0x0000;
1024 prop_text_out
.foreground
->green
= 0xffff;
1025 prop_text_out
.foreground
->blue
= 0x0000;
1029 prop_text_out
.foreground
->red
= 0xffff;
1030 prop_text_out
.foreground
->green
= 0xffff;
1031 prop_text_out
.foreground
->blue
= 0xffff;
1035 /* Print status of the process : U, WF, WC, E, W, R */
1036 if(process_out
->state
->s
== LTTV_STATE_UNNAMED
)
1037 prop_text_out
.text
= "U->";
1038 else if(process_out
->state
->s
== LTTV_STATE_WAIT_FORK
)
1039 prop_text_out
.text
= "WF->";
1040 else if(process_out
->state
->s
== LTTV_STATE_WAIT_CPU
)
1041 prop_text_out
.text
= "WC->";
1042 else if(process_out
->state
->s
== LTTV_STATE_ZOMBIE
)
1043 prop_text_out
.text
= "E->";
1044 else if(process_out
->state
->s
== LTTV_STATE_WAIT
)
1045 prop_text_out
.text
= "W->";
1046 else if(process_out
->state
->s
== LTTV_STATE_RUN
)
1047 prop_text_out
.text
= "R->";
1049 prop_text_out
.text
= "U";
1051 draw_text((void*)&prop_text_out
, (void*)draw_context_out
);
1052 //gdk_gc_unref(draw_context_out->gc);
1054 //draw_context_out->gc = gdk_gc_new(control_flow_data->drawing->pixmap);
1055 //gdk_gc_copy(draw_context_out->gc, widget->style->black_gc);
1056 draw_context_out
->gc
= control_flow_data
->drawing
->gc
;
1058 PropertiesLine prop_line_out
;
1059 prop_line_out
.color
= g_new(GdkColor
,1);
1060 prop_line_out
.line_width
= 2;
1061 prop_line_out
.style
= GDK_LINE_SOLID
;
1062 prop_line_out
.position
= MIDDLE
;
1064 g_debug("out state : %s", g_quark_to_string(process_out
->state
->s
));
1066 /* color of line : status of the process */
1067 if(process_out
->state
->s
== LTTV_STATE_UNNAMED
)
1069 prop_line_out
.color
->red
= 0xffff;
1070 prop_line_out
.color
->green
= 0xffff;
1071 prop_line_out
.color
->blue
= 0xffff;
1073 else if(process_out
->state
->s
== LTTV_STATE_WAIT_FORK
)
1075 prop_line_out
.color
->red
= 0x0fff;
1076 prop_line_out
.color
->green
= 0xffff;
1077 prop_line_out
.color
->blue
= 0xfff0;
1079 else if(process_out
->state
->s
== LTTV_STATE_WAIT_CPU
)
1081 prop_line_out
.color
->red
= 0xffff;
1082 prop_line_out
.color
->green
= 0xffff;
1083 prop_line_out
.color
->blue
= 0x0000;
1085 else if(process_out
->state
->s
== LTTV_STATE_ZOMBIE
)
1087 prop_line_out
.color
->red
= 0xffff;
1088 prop_line_out
.color
->green
= 0x0000;
1089 prop_line_out
.color
->blue
= 0xffff;
1091 else if(process_out
->state
->s
== LTTV_STATE_WAIT
)
1093 prop_line_out
.color
->red
= 0xffff;
1094 prop_line_out
.color
->green
= 0x0000;
1095 prop_line_out
.color
->blue
= 0x0000;
1097 else if(process_out
->state
->s
== LTTV_STATE_RUN
)
1099 prop_line_out
.color
->red
= 0x0000;
1100 prop_line_out
.color
->green
= 0xffff;
1101 prop_line_out
.color
->blue
= 0x0000;
1105 prop_line_out
.color
->red
= 0xffff;
1106 prop_line_out
.color
->green
= 0xffff;
1107 prop_line_out
.color
->blue
= 0xffff;
1110 draw_line((void*)&prop_line_out
, (void*)draw_context_out
);
1111 g_free(prop_line_out
.color
);
1112 //gdk_gc_unref(draw_context_out->gc);
1113 /* Note : finishing line will have to be added when trace read over. */
1115 /* Finally, update the drawing context of the pid_in. */
1117 DrawContext
*draw_context_in
= hashed_process_data_in
->draw_context
;
1118 draw_context_in
->current
->modify_over
->x
= x
;
1119 draw_context_in
->current
->modify_under
->x
= x
;
1120 draw_context_in
->current
->modify_over
->y
= y_in
;
1121 draw_context_in
->current
->modify_under
->y
= y_in
+(height
/2)+2;
1122 draw_context_in
->drawable
= control_flow_data
->drawing
->pixmap
;
1123 draw_context_in
->pango_layout
= control_flow_data
->drawing
->pango_layout
;
1124 widget
= control_flow_data
->drawing
->drawing_area
;
1125 //draw_context_in->gc = widget->style->fg_gc[GTK_WIDGET_STATE (widget)];
1126 //draw_context_in->gc = widget->style->black_gc;
1127 //draw_context_in->gc = gdk_gc_new(control_flow_data->drawing->pixmap);
1128 //gdk_gc_copy(draw_context_in->gc, widget->style->black_gc);
1130 //draw_arc((void*)&prop_arc, (void*)draw_context_in);
1131 //test_draw_item(control_flow_data->drawing, control_flow_data->drawing->pixmap);
1133 /* Draw the line/bg of the in process */
1134 if(draw_context_in
->previous
->middle
->x
== -1)
1136 draw_context_in
->previous
->over
->x
=
1137 control_flow_data
->drawing
->damage_begin
;
1138 draw_context_in
->previous
->middle
->x
=
1139 control_flow_data
->drawing
->damage_begin
;
1140 draw_context_in
->previous
->under
->x
=
1141 control_flow_data
->drawing
->damage_begin
;
1143 g_debug("in middle x_beg : %u",control_flow_data
->drawing
->damage_begin
);
1147 draw_context_in
->current
->middle
->x
= x
;
1148 draw_context_in
->current
->over
->x
= x
;
1149 draw_context_in
->current
->under
->x
= x
;
1150 draw_context_in
->current
->middle
->y
= y_in
+ height
/2;
1151 draw_context_in
->current
->over
->y
= y_in
;
1152 draw_context_in
->current
->under
->y
= y_in
+ height
;
1153 draw_context_in
->previous
->middle
->y
= y_in
+ height
/2;
1154 draw_context_in
->previous
->over
->y
= y_in
;
1155 draw_context_in
->previous
->under
->y
= y_in
+ height
;
1157 draw_context_in
->drawable
= control_flow_data
->drawing
->pixmap
;
1158 draw_context_in
->pango_layout
= control_flow_data
->drawing
->pango_layout
;
1161 if(process_in
->state
->s
== LTTV_STATE_RUN
)
1163 //draw_context_in->gc = gdk_gc_new(control_flow_data->drawing->pixmap);
1164 //gdk_gc_copy(draw_context_in->gc, widget->style->black_gc);
1165 draw_context_in
->gc
= control_flow_data
->drawing
->gc
;
1167 PropertiesBG prop_bg
;
1168 prop_bg
.color
= g_new(GdkColor
,1);
1170 switch(tfc
->index
) {
1172 prop_bg
.color
->red
= 0x1515;
1173 prop_bg
.color
->green
= 0x1515;
1174 prop_bg
.color
->blue
= 0x8c8c;
1177 prop_bg
.color
->red
= 0x4e4e;
1178 prop_bg
.color
->green
= 0xa9a9;
1179 prop_bg
.color
->blue
= 0xa4a4;
1182 prop_bg
.color
->red
= 0x7a7a;
1183 prop_bg
.color
->green
= 0x4a4a;
1184 prop_bg
.color
->blue
= 0x8b8b;
1187 prop_bg
.color
->red
= 0x8080;
1188 prop_bg
.color
->green
= 0x7777;
1189 prop_bg
.color
->blue
= 0x4747;
1192 prop_bg
.color
->red
= 0xe7e7;
1193 prop_bg
.color
->green
= 0xe7e7;
1194 prop_bg
.color
->blue
= 0xe7e7;
1198 draw_bg((void*)&prop_bg
, (void*)draw_context_in
);
1199 g_free(prop_bg
.color
);
1200 //gdk_gc_unref(draw_context_in->gc);
1203 draw_context_in
->gc
= widget
->style
->black_gc
;
1205 GdkColor colorfg_in
= { 0, 0x0000, 0xffff, 0x0000 };
1206 GdkColor colorbg_in
= { 0, 0x0000, 0x0000, 0x0000 };
1207 PropertiesText prop_text_in
;
1208 prop_text_in
.foreground
= &colorfg_in
;
1209 prop_text_in
.background
= &colorbg_in
;
1210 prop_text_in
.size
= 6;
1211 prop_text_in
.position
= OVER
;
1213 g_debug("in state : %s", g_quark_to_string(process_in
->state
->s
));
1214 /* foreground of text : status of the process */
1215 if(process_in
->state
->s
== LTTV_STATE_UNNAMED
)
1217 prop_text_in
.foreground
->red
= 0xffff;
1218 prop_text_in
.foreground
->green
= 0xffff;
1219 prop_text_in
.foreground
->blue
= 0xffff;
1221 else if(process_in
->state
->s
== LTTV_STATE_WAIT_FORK
)
1223 prop_text_in
.foreground
->red
= 0x0fff;
1224 prop_text_in
.foreground
->green
= 0xffff;
1225 prop_text_in
.foreground
->blue
= 0xfff0;
1227 else if(process_in
->state
->s
== LTTV_STATE_WAIT_CPU
)
1229 prop_text_in
.foreground
->red
= 0xffff;
1230 prop_text_in
.foreground
->green
= 0xffff;
1231 prop_text_in
.foreground
->blue
= 0x0000;
1233 else if(process_in
->state
->s
== LTTV_STATE_ZOMBIE
)
1235 prop_text_in
.foreground
->red
= 0xffff;
1236 prop_text_in
.foreground
->green
= 0x0000;
1237 prop_text_in
.foreground
->blue
= 0xffff;
1239 else if(process_in
->state
->s
== LTTV_STATE_WAIT
)
1241 prop_text_in
.foreground
->red
= 0xffff;
1242 prop_text_in
.foreground
->green
= 0x0000;
1243 prop_text_in
.foreground
->blue
= 0x0000;
1245 else if(process_in
->state
->s
== LTTV_STATE_RUN
)
1247 prop_text_in
.foreground
->red
= 0x0000;
1248 prop_text_in
.foreground
->green
= 0xffff;
1249 prop_text_in
.foreground
->blue
= 0x0000;
1253 prop_text_in
.foreground
->red
= 0xffff;
1254 prop_text_in
.foreground
->green
= 0xffff;
1255 prop_text_in
.foreground
->blue
= 0xffff;
1260 /* Print status of the process : U, WF, WC, E, W, R */
1261 if(process_in
->state
->s
== LTTV_STATE_UNNAMED
)
1262 prop_text_in
.text
= "U->";
1263 else if(process_in
->state
->s
== LTTV_STATE_WAIT_FORK
)
1264 prop_text_in
.text
= "WF->";
1265 else if(process_in
->state
->s
== LTTV_STATE_WAIT_CPU
)
1266 prop_text_in
.text
= "WC->";
1267 else if(process_in
->state
->s
== LTTV_STATE_ZOMBIE
)
1268 prop_text_in
.text
= "E->";
1269 else if(process_in
->state
->s
== LTTV_STATE_WAIT
)
1270 prop_text_in
.text
= "W->";
1271 else if(process_in
->state
->s
== LTTV_STATE_RUN
)
1272 prop_text_in
.text
= "R->";
1274 prop_text_in
.text
= "U";
1276 draw_text((void*)&prop_text_in
, (void*)draw_context_in
);
1277 //gdk_gc_unref(draw_context_in->gc);
1279 //draw_context_in->gc = gdk_gc_new(control_flow_data->drawing->pixmap);
1280 //gdk_gc_copy(draw_context_in->gc, widget->style->black_gc);
1281 draw_context_in
->gc
= control_flow_data
->drawing
->gc
;
1283 PropertiesLine prop_line_in
;
1284 prop_line_in
.color
= g_new(GdkColor
,1);
1285 prop_line_in
.line_width
= 2;
1286 prop_line_in
.style
= GDK_LINE_SOLID
;
1287 prop_line_in
.position
= MIDDLE
;
1289 /* color of line : status of the process */
1290 if(process_in
->state
->s
== LTTV_STATE_UNNAMED
)
1292 prop_line_in
.color
->red
= 0xffff;
1293 prop_line_in
.color
->green
= 0xffff;
1294 prop_line_in
.color
->blue
= 0xffff;
1296 else if(process_in
->state
->s
== LTTV_STATE_WAIT_FORK
)
1298 prop_line_in
.color
->red
= 0x0fff;
1299 prop_line_in
.color
->green
= 0xffff;
1300 prop_line_in
.color
->blue
= 0xfff0;
1302 else if(process_in
->state
->s
== LTTV_STATE_WAIT_CPU
)
1304 prop_line_in
.color
->red
= 0xffff;
1305 prop_line_in
.color
->green
= 0xffff;
1306 prop_line_in
.color
->blue
= 0x0000;
1308 else if(process_in
->state
->s
== LTTV_STATE_ZOMBIE
)
1310 prop_line_in
.color
->red
= 0xffff;
1311 prop_line_in
.color
->green
= 0x0000;
1312 prop_line_in
.color
->blue
= 0xffff;
1314 else if(process_in
->state
->s
== LTTV_STATE_WAIT
)
1316 prop_line_in
.color
->red
= 0xffff;
1317 prop_line_in
.color
->green
= 0x0000;
1318 prop_line_in
.color
->blue
= 0x0000;
1320 else if(process_in
->state
->s
== LTTV_STATE_RUN
)
1322 prop_line_in
.color
->red
= 0x0000;
1323 prop_line_in
.color
->green
= 0xffff;
1324 prop_line_in
.color
->blue
= 0x0000;
1328 prop_line_in
.color
->red
= 0xffff;
1329 prop_line_in
.color
->green
= 0xffff;
1330 prop_line_in
.color
->blue
= 0xffff;
1333 draw_line((void*)&prop_line_in
, (void*)draw_context_in
);
1334 g_free(prop_line_in
.color
);
1335 //gdk_gc_unref(draw_context_in->gc);
1345 GString
*string
= g_string_new("");;
1346 gboolean field_names
= TRUE
, state
= TRUE
;
1348 lttv_event_to_string(e
, tfc
->tf
, string
, TRUE
, field_names
, tfs
);
1349 g_string_append_printf(string
,"\n");
1352 g_string_append_printf(string
, " %s",
1353 g_quark_to_string(tfs
->process
->state
->s
));
1356 g_info("%s",string
->str
);
1358 g_string_free(string
, TRUE
);
1360 /* End of text dump */
1365 /* after_schedchange_hook
1367 * The draw after hook is called by the reading API to have a
1368 * particular event drawn on the screen.
1369 * @param hook_data ControlFlowData structure of the viewer.
1370 * @param call_data Event context.
1372 * This function adds items to be drawn in a queue for each process.
1375 int after_schedchange_hook(void *hook_data
, void *call_data
)
1377 EventsRequest
*events_request
= (EventsRequest
*)hook_data
;
1378 ControlFlowData
*control_flow_data
= events_request
->viewer_data
;
1380 LttvTracefileContext
*tfc
= (LttvTracefileContext
*)call_data
;
1382 LttvTracefileState
*tfs
= (LttvTracefileState
*)call_data
;
1383 LttvTraceState
*ts
=(LttvTraceState
*)((LttvTracefileContext
*)tfs
)->t_context
;
1388 LttTime evtime
= ltt_event_time(e
);
1390 guint width
= control_flow_data
->drawing
->width
;
1392 /* Add process to process list (if not present) */
1393 LttvProcessState
*process_out
, *process_in
;
1395 guint y_in
= 0, y_out
= 0, height
= 0, pl_height
= 0;
1396 HashedProcessData
*hashed_process_data_in
= NULL
;
1398 ProcessList
*process_list
= control_flow_data
->process_list
;
1403 LttField
*f
= ltt_event_field(e
);
1405 element
= ltt_field_member(f
,0);
1406 pid_out
= ltt_event_get_long_unsigned(e
,element
);
1407 element
= ltt_field_member(f
,1);
1408 pid_in
= ltt_event_get_long_unsigned(e
,element
);
1409 g_debug("out : %u in : %u", pid_out
, pid_in
);
1413 /* Find process pid_in in the list... */
1414 //process_in = lttv_state_find_process(tfs, pid_in);
1415 process_in
= tfs
->process
;
1416 /* It should exist, because we are after the state update. */
1417 g_assert(process_in
!= NULL
);
1419 birth
= process_in
->creation_time
;
1421 hashed_process_data_in
= processlist_get_process_data(process_list
,
1423 process_in
->last_cpu_index
,
1425 tfc
->t_context
->index
);
1426 if(hashed_process_data_in
== NULL
)
1428 g_assert(pid_in
== 0 || pid_in
!= process_in
->ppid
);
1429 const gchar
*name
= g_quark_to_string(process_in
->name
);
1430 ProcessInfo
*process_info
;
1431 /* Process not present */
1432 processlist_add(process_list
,
1434 process_in
->last_cpu_index
,
1437 tfc
->t_context
->index
,
1441 &hashed_process_data_in
);
1442 processlist_get_pixels_from_data(process_list
,
1443 hashed_process_data_in
,
1446 drawing_insert_square( control_flow_data
->drawing
, y_in
, height
);
1448 /* Set the current process */
1449 process_list
->current_hash_data
[process_in
->last_cpu_index
] =
1450 hashed_process_data_in
;
1452 if(ltt_time_compare(hashed_process_data_in
->next_good_time
,
1455 processlist_get_pixels_from_data(process_list
,
1456 hashed_process_data_in
,
1459 TimeWindow time_window
=
1460 lttvwindow_get_time_window(control_flow_data
->tab
);
1463 if(ltt_time_compare(evtime
, time_window
.start_time
) == -1
1464 || ltt_time_compare(evtime
, time_window
.end_time
) == 1)
1466 #endif //EXTRA_CHECK
1470 convert_time_to_pixels(
1476 if(hashed_process_data_in
->x
.middle
!= new_x
) {
1477 hashed_process_data_in
->x
.middle
= new_x
;
1478 hashed_process_data_in
->x
.middle_used
= FALSE
;
1479 hashed_process_data_in
->x
.middle_marked
= FALSE
;
1489 EventsRequest
*events_request
= (EventsRequest
*)hook_data
;
1490 ControlFlowData
*control_flow_data
= events_request
->viewer_data
;
1492 LttvTracefileContext
*tfc
= (LttvTracefileContext
*)call_data
;
1494 LttvTracefileState
*tfs
= (LttvTracefileState
*)call_data
;
1495 LttvTraceState
*ts
=(LttvTraceState
*)LTTV_TRACEFILE_CONTEXT(tfs
)->t_context
;
1501 LttTime evtime
= ltt_event_time(e
);
1502 TimeWindow time_window
=
1503 lttvwindow_get_time_window(control_flow_data
->tab
);
1505 LttTime time_window
.end_time
= time_window
.time_window
.end_time
;
1507 //if(time < time_beg || time > time_end) return;
1508 if(ltt_time_compare(evtime
, time_window
.start_time
) == -1
1509 || ltt_time_compare(evtime
, time_window
.end_time
) == 1)
1513 if(strcmp(ltt_eventtype_name(ltt_event_eventtype(e
)),"schedchange") == 0)
1515 g_debug("schedchange!");
1517 /* Add process to process list (if not present) and get drawing "y" from
1518 * process position */
1519 guint pid_out
, pid_in
;
1520 LttvProcessState
*process_out
, *process_in
;
1522 guint y_in
= 0, y_out
= 0, height
= 0, pl_height
= 0;
1524 ProcessList
*process_list
= control_flow_data
->process_list
;
1527 LttField
*f
= ltt_event_field(e
);
1529 element
= ltt_field_member(f
,0);
1530 pid_out
= ltt_event_get_long_unsigned(e
,element
);
1531 element
= ltt_field_member(f
,1);
1532 pid_in
= ltt_event_get_long_unsigned(e
,element
);
1533 //g_debug("out : %u in : %u", pid_out, pid_in);
1536 /* Find process pid_out in the list... */
1537 process_out
= lttv_state_find_process(tfs
, pid_out
);
1538 if(process_out
== NULL
) return 0;
1539 //g_debug("out : %s",g_quark_to_string(process_out->state->s));
1541 birth
= process_out
->creation_time
;
1542 gchar
*name
= strdup(g_quark_to_string(process_out
->name
));
1543 HashedProcessData
*hashed_process_data_out
= NULL
;
1545 if(processlist_get_process_pixels(process_list
,
1548 tfc
->t_context
->index
,
1551 &hashed_process_data_out
) == 1)
1553 /* Process not present */
1554 processlist_add(process_list
,
1557 tfc
->t_context
->index
,
1560 &hashed_process_data_out
);
1561 processlist_get_process_pixels(process_list
,
1564 tfc
->t_context
->index
,
1567 &hashed_process_data_out
);
1568 drawing_insert_square( control_flow_data
->drawing
, y_out
, height
);
1573 /* Find process pid_in in the list... */
1574 process_in
= lttv_state_find_process(tfs
, pid_in
);
1575 if(process_in
== NULL
) return 0;
1576 //g_debug("in : %s",g_quark_to_string(process_in->state->s));
1578 birth
= process_in
->creation_time
;
1579 name
= strdup(g_quark_to_string(process_in
->name
));
1580 HashedProcessData
*hashed_process_data_in
= NULL
;
1582 if(processlist_get_process_pixels(process_list
,
1585 tfc
->t_context
->index
,
1588 &hashed_process_data_in
) == 1)
1590 /* Process not present */
1591 processlist_add(process_list
,
1594 tfc
->t_context
->index
,
1597 &hashed_process_data_in
);
1598 processlist_get_process_pixels(process_list
,
1601 tfc
->t_context
->index
,
1604 &hashed_process_data_in
);
1606 drawing_insert_square( control_flow_data
->drawing
, y_in
, height
);
1611 /* Find pixels corresponding to time of the event. If the time does
1612 * not fit in the window, show a warning, not supposed to happend. */
1614 //guint width = control_flow_data->drawing->drawing_area->allocation.width;
1616 //LttTime time = ltt_event_time(e);
1618 //LttTime window_end = time_window->time_window.end_time;
1621 //convert_time_to_pixels(
1627 //assert(x <= width);
1629 /* draw what represents the event for outgoing process. */
1631 DrawContext
*draw_context_out
= hashed_process_data_out
->draw_context
;
1632 //draw_context_out->current->modify_over->x = x;
1633 draw_context_out
->current
->modify_over
->y
= y_out
;
1634 draw_context_out
->current
->modify_under
->y
= y_out
+(height
/2)+2;
1635 draw_context_out
->drawable
= control_flow_data
->drawing
->pixmap
;
1636 draw_context_out
->pango_layout
= control_flow_data
->drawing
->pango_layout
;
1637 GtkWidget
*widget
= control_flow_data
->drawing
->drawing_area
;
1638 //draw_context_out->gc = widget->style->fg_gc[GTK_WIDGET_STATE (widget)];
1640 //draw_arc((void*)&prop_arc, (void*)draw_context_out);
1641 //test_draw_item(control_flow_data->drawing, control_flow_data->drawing->pixmap);
1643 /*if(process_out->state->s == LTTV_STATE_RUN)
1645 draw_context_out->gc = gdk_gc_new(control_flow_data->drawing->pixmap);
1646 gdk_gc_copy(draw_context_out->gc, widget->style->black_gc);
1647 PropertiesBG prop_bg;
1648 prop_bg.color = g_new(GdkColor,1);
1650 prop_bg.color->red = 0xffff;
1651 prop_bg.color->green = 0xffff;
1652 prop_bg.color->blue = 0xffff;
1654 draw_bg((void*)&prop_bg, (void*)draw_context_out);
1655 g_free(prop_bg.color);
1656 gdk_gc_unref(draw_context_out->gc);
1659 draw_context_out
->gc
= widget
->style
->black_gc
;
1661 GdkColor colorfg_out
= { 0, 0xffff, 0x0000, 0x0000 };
1662 GdkColor colorbg_out
= { 0, 0x0000, 0x0000, 0x0000 };
1663 PropertiesText prop_text_out
;
1664 prop_text_out
.foreground
= &colorfg_out
;
1665 prop_text_out
.background
= &colorbg_out
;
1666 prop_text_out
.size
= 6;
1667 prop_text_out
.position
= OVER
;
1669 /* color of text : status of the process */
1670 if(process_out
->state
->s
== LTTV_STATE_UNNAMED
)
1672 prop_text_out
.foreground
->red
= 0xffff;
1673 prop_text_out
.foreground
->green
= 0xffff;
1674 prop_text_out
.foreground
->blue
= 0xffff;
1676 else if(process_out
->state
->s
== LTTV_STATE_WAIT_FORK
)
1678 prop_text_out
.foreground
->red
= 0x0fff;
1679 prop_text_out
.foreground
->green
= 0xffff;
1680 prop_text_out
.foreground
->blue
= 0xfff0;
1682 else if(process_out
->state
->s
== LTTV_STATE_WAIT_CPU
)
1684 prop_text_out
.foreground
->red
= 0xffff;
1685 prop_text_out
.foreground
->green
= 0xffff;
1686 prop_text_out
.foreground
->blue
= 0x0000;
1688 else if(process_out
->state
->s
== LTTV_STATE_ZOMBIE
)
1690 prop_text_out
.foreground
->red
= 0xffff;
1691 prop_text_out
.foreground
->green
= 0x0000;
1692 prop_text_out
.foreground
->blue
= 0xffff;
1694 else if(process_out
->state
->s
== LTTV_STATE_WAIT
)
1696 prop_text_out
.foreground
->red
= 0xffff;
1697 prop_text_out
.foreground
->green
= 0x0000;
1698 prop_text_out
.foreground
->blue
= 0x0000;
1700 else if(process_out
->state
->s
== LTTV_STATE_RUN
)
1702 prop_text_out
.foreground
->red
= 0x0000;
1703 prop_text_out
.foreground
->green
= 0xffff;
1704 prop_text_out
.foreground
->blue
= 0x0000;
1708 prop_text_out
.foreground
->red
= 0xffff;
1709 prop_text_out
.foreground
->green
= 0xffff;
1710 prop_text_out
.foreground
->blue
= 0xffff;
1713 /* Print status of the process : U, WF, WC, E, W, R */
1714 if(process_out
->state
->s
== LTTV_STATE_UNNAMED
)
1715 prop_text_out
.text
= "U";
1716 else if(process_out
->state
->s
== LTTV_STATE_WAIT_FORK
)
1717 prop_text_out
.text
= "WF";
1718 else if(process_out
->state
->s
== LTTV_STATE_WAIT_CPU
)
1719 prop_text_out
.text
= "WC";
1720 else if(process_out
->state
->s
== LTTV_STATE_ZOMBIE
)
1721 prop_text_out
.text
= "E";
1722 else if(process_out
->state
->s
== LTTV_STATE_WAIT
)
1723 prop_text_out
.text
= "W";
1724 else if(process_out
->state
->s
== LTTV_STATE_RUN
)
1725 prop_text_out
.text
= "R";
1727 prop_text_out
.text
= "U";
1729 draw_text((void*)&prop_text_out
, (void*)draw_context_out
);
1731 //gdk_gc_unref(draw_context_out->gc);
1733 draw_context_out
->current
->middle
->y
= y_out
+height
/2;
1734 draw_context_out
->current
->over
->y
= y_out
;
1735 draw_context_out
->current
->under
->y
= y_out
+height
;
1736 draw_context_out
->current
->status
= process_out
->state
->s
;
1738 /* for pid_out : remove previous, Prev = current, new current (default) */
1739 g_free(draw_context_out
->previous
->modify_under
);
1740 g_free(draw_context_out
->previous
->modify_middle
);
1741 g_free(draw_context_out
->previous
->modify_over
);
1742 g_free(draw_context_out
->previous
->under
);
1743 g_free(draw_context_out
->previous
->middle
);
1744 g_free(draw_context_out
->previous
->over
);
1745 g_free(draw_context_out
->previous
);
1747 draw_context_out
->previous
= draw_context_out
->current
;
1749 draw_context_out
->current
= g_new(DrawInfo
,1);
1750 draw_context_out
->current
->over
= g_new(ItemInfo
,1);
1751 draw_context_out
->current
->over
->x
= -1;
1752 draw_context_out
->current
->over
->y
= -1;
1753 draw_context_out
->current
->middle
= g_new(ItemInfo
,1);
1754 draw_context_out
->current
->middle
->x
= -1;
1755 draw_context_out
->current
->middle
->y
= -1;
1756 draw_context_out
->current
->under
= g_new(ItemInfo
,1);
1757 draw_context_out
->current
->under
->x
= -1;
1758 draw_context_out
->current
->under
->y
= -1;
1759 draw_context_out
->current
->modify_over
= g_new(ItemInfo
,1);
1760 draw_context_out
->current
->modify_over
->x
= -1;
1761 draw_context_out
->current
->modify_over
->y
= -1;
1762 draw_context_out
->current
->modify_middle
= g_new(ItemInfo
,1);
1763 draw_context_out
->current
->modify_middle
->x
= -1;
1764 draw_context_out
->current
->modify_middle
->y
= -1;
1765 draw_context_out
->current
->modify_under
= g_new(ItemInfo
,1);
1766 draw_context_out
->current
->modify_under
->x
= -1;
1767 draw_context_out
->current
->modify_under
->y
= -1;
1768 draw_context_out
->current
->status
= LTTV_STATE_UNNAMED
;
1770 /* Finally, update the drawing context of the pid_in. */
1772 DrawContext
*draw_context_in
= hashed_process_data_in
->draw_context
;
1773 //draw_context_in->current->modify_over->x = x;
1774 draw_context_in
->current
->modify_over
->y
= y_in
;
1775 draw_context_in
->current
->modify_under
->y
= y_in
+(height
/2)+2;
1776 draw_context_in
->drawable
= control_flow_data
->drawing
->pixmap
;
1777 draw_context_in
->pango_layout
= control_flow_data
->drawing
->pango_layout
;
1778 widget
= control_flow_data
->drawing
->drawing_area
;
1779 //draw_context_in->gc = widget->style->fg_gc[GTK_WIDGET_STATE (widget)];
1781 //draw_arc((void*)&prop_arc, (void*)draw_context_in);
1782 //test_draw_item(control_flow_data->drawing, control_flow_data->drawing->pixmap);
1784 /*if(process_in->state->s == LTTV_STATE_RUN)
1786 draw_context_in->gc = gdk_gc_new(control_flow_data->drawing->pixmap);
1787 gdk_gc_copy(draw_context_in->gc, widget->style->black_gc);
1788 PropertiesBG prop_bg;
1789 prop_bg.color = g_new(GdkColor,1);
1791 prop_bg.color->red = 0xffff;
1792 prop_bg.color->green = 0xffff;
1793 prop_bg.color->blue = 0xffff;
1795 draw_bg((void*)&prop_bg, (void*)draw_context_in);
1796 g_free(prop_bg.color);
1797 gdk_gc_unref(draw_context_in->gc);
1800 draw_context_in
->gc
= widget
->style
->black_gc
;
1802 GdkColor colorfg_in
= { 0, 0x0000, 0xffff, 0x0000 };
1803 GdkColor colorbg_in
= { 0, 0x0000, 0x0000, 0x0000 };
1804 PropertiesText prop_text_in
;
1805 prop_text_in
.foreground
= &colorfg_in
;
1806 prop_text_in
.background
= &colorbg_in
;
1807 prop_text_in
.size
= 6;
1808 prop_text_in
.position
= OVER
;
1810 /* foreground of text : status of the process */
1811 if(process_in
->state
->s
== LTTV_STATE_UNNAMED
)
1813 prop_text_in
.foreground
->red
= 0xffff;
1814 prop_text_in
.foreground
->green
= 0xffff;
1815 prop_text_in
.foreground
->blue
= 0xffff;
1817 else if(process_in
->state
->s
== LTTV_STATE_WAIT_FORK
)
1819 prop_text_in
.foreground
->red
= 0x0fff;
1820 prop_text_in
.foreground
->green
= 0xffff;
1821 prop_text_in
.foreground
->blue
= 0xfff0;
1823 else if(process_in
->state
->s
== LTTV_STATE_WAIT_CPU
)
1825 prop_text_in
.foreground
->red
= 0xffff;
1826 prop_text_in
.foreground
->green
= 0xffff;
1827 prop_text_in
.foreground
->blue
= 0x0000;
1829 else if(process_in
->state
->s
== LTTV_STATE_ZOMBIE
)
1831 prop_text_in
.foreground
->red
= 0xffff;
1832 prop_text_in
.foreground
->green
= 0x0000;
1833 prop_text_in
.foreground
->blue
= 0xffff;
1835 else if(process_in
->state
->s
== LTTV_STATE_WAIT
)
1837 prop_text_in
.foreground
->red
= 0xffff;
1838 prop_text_in
.foreground
->green
= 0x0000;
1839 prop_text_in
.foreground
->blue
= 0x0000;
1841 else if(process_in
->state
->s
== LTTV_STATE_RUN
)
1843 prop_text_in
.foreground
->red
= 0x0000;
1844 prop_text_in
.foreground
->green
= 0xffff;
1845 prop_text_in
.foreground
->blue
= 0x0000;
1849 prop_text_in
.foreground
->red
= 0xffff;
1850 prop_text_in
.foreground
->green
= 0xffff;
1851 prop_text_in
.foreground
->blue
= 0xffff;
1855 /* Print status of the process : U, WF, WC, E, W, R */
1856 if(process_in
->state
->s
== LTTV_STATE_UNNAMED
)
1857 prop_text_in
.text
= "U";
1858 else if(process_in
->state
->s
== LTTV_STATE_WAIT_FORK
)
1859 prop_text_in
.text
= "WF";
1860 else if(process_in
->state
->s
== LTTV_STATE_WAIT_CPU
)
1861 prop_text_in
.text
= "WC";
1862 else if(process_in
->state
->s
== LTTV_STATE_ZOMBIE
)
1863 prop_text_in
.text
= "E";
1864 else if(process_in
->state
->s
== LTTV_STATE_WAIT
)
1865 prop_text_in
.text
= "W";
1866 else if(process_in
->state
->s
== LTTV_STATE_RUN
)
1867 prop_text_in
.text
= "R";
1869 prop_text_in
.text
= "U";
1871 draw_text((void*)&prop_text_in
, (void*)draw_context_in
);
1874 if(process_in
->state
->s
== LTTV_STATE_RUN
)
1877 prop_text_in
.foreground
= &colorfg_in
;
1878 prop_text_in
.background
= &colorbg_in
;
1879 prop_text_in
.foreground
->red
= 0xffff;
1880 prop_text_in
.foreground
->green
= 0xffff;
1881 prop_text_in
.foreground
->blue
= 0xffff;
1882 prop_text_in
.size
= 6;
1883 prop_text_in
.position
= UNDER
;
1885 prop_text_in
.text
= g_new(gchar
, 260);
1886 strcpy(prop_text_in
.text
, "CPU ");
1887 snprintf(tmp
, 255, "%u", tfc
->index
);
1888 strcat(prop_text_in
.text
, tmp
);
1890 draw_text((void*)&prop_text_in
, (void*)draw_context_in
);
1891 g_free(prop_text_in
.text
);
1895 draw_context_in
->current
->middle
->y
= y_in
+height
/2;
1896 draw_context_in
->current
->over
->y
= y_in
;
1897 draw_context_in
->current
->under
->y
= y_in
+height
;
1898 draw_context_in
->current
->status
= process_in
->state
->s
;
1900 /* for pid_in : remove previous, Prev = current, new current (default) */
1901 g_free(draw_context_in
->previous
->modify_under
);
1902 g_free(draw_context_in
->previous
->modify_middle
);
1903 g_free(draw_context_in
->previous
->modify_over
);
1904 g_free(draw_context_in
->previous
->under
);
1905 g_free(draw_context_in
->previous
->middle
);
1906 g_free(draw_context_in
->previous
->over
);
1907 g_free(draw_context_in
->previous
);
1909 draw_context_in
->previous
= draw_context_in
->current
;
1911 draw_context_in
->current
= g_new(DrawInfo
,1);
1912 draw_context_in
->current
->over
= g_new(ItemInfo
,1);
1913 draw_context_in
->current
->over
->x
= -1;
1914 draw_context_in
->current
->over
->y
= -1;
1915 draw_context_in
->current
->middle
= g_new(ItemInfo
,1);
1916 draw_context_in
->current
->middle
->x
= -1;
1917 draw_context_in
->current
->middle
->y
= -1;
1918 draw_context_in
->current
->under
= g_new(ItemInfo
,1);
1919 draw_context_in
->current
->under
->x
= -1;
1920 draw_context_in
->current
->under
->y
= -1;
1921 draw_context_in
->current
->modify_over
= g_new(ItemInfo
,1);
1922 draw_context_in
->current
->modify_over
->x
= -1;
1923 draw_context_in
->current
->modify_over
->y
= -1;
1924 draw_context_in
->current
->modify_middle
= g_new(ItemInfo
,1);
1925 draw_context_in
->current
->modify_middle
->x
= -1;
1926 draw_context_in
->current
->modify_middle
->y
= -1;
1927 draw_context_in
->current
->modify_under
= g_new(ItemInfo
,1);
1928 draw_context_in
->current
->modify_under
->x
= -1;
1929 draw_context_in
->current
->modify_under
->y
= -1;
1930 draw_context_in
->current
->status
= LTTV_STATE_UNNAMED
;
1939 static inline PropertiesLine
prepare_execmode_line(LttvProcessState
*process
)
1941 PropertiesLine prop_line
;
1942 prop_line
.line_width
= 1;
1943 prop_line
.style
= GDK_LINE_SOLID
;
1945 //GdkColormap *colormap = gdk_colormap_get_system();
1947 /* color of line : execution mode of the process */
1948 if(process
->state
->t
== LTTV_STATE_USER_MODE
)
1949 prop_line
.color
= drawing_colors
[COL_USER_MODE
];
1950 else if(process
->state
->t
== LTTV_STATE_SYSCALL
)
1951 prop_line
.color
= drawing_colors
[COL_SYSCALL
];
1952 else if(process
->state
->t
== LTTV_STATE_TRAP
)
1953 prop_line
.color
= drawing_colors
[COL_TRAP
];
1954 else if(process
->state
->t
== LTTV_STATE_IRQ
)
1955 prop_line
.color
= drawing_colors
[COL_IRQ
];
1956 else if(process
->state
->t
== LTTV_STATE_MODE_UNKNOWN
)
1957 prop_line
.color
= drawing_colors
[COL_MODE_UNKNOWN
];
1959 prop_line
.color
= drawing_colors
[COL_WHITE
];
1961 //gdk_colormap_alloc_color(colormap,
1972 /* before_execmode_hook
1974 * This function basically draw lines and icons. Two types of lines are drawn :
1975 * one small (3 pixels?) representing the state of the process and the second
1976 * type is thicker (10 pixels?) representing on which CPU a process is running
1977 * (and this only in running state).
1979 * Extremums of the lines :
1980 * x_min : time of the last event context for this process kept in memory.
1981 * x_max : time of the current event.
1982 * y : middle of the process in the process list. The process is found in the
1983 * list, therefore is it's position in pixels.
1985 * The choice of lines'color is defined by the context of the last event for this
1990 int before_execmode_hook(void *hook_data
, void *call_data
)
1992 EventsRequest
*events_request
= (EventsRequest
*)hook_data
;
1993 ControlFlowData
*control_flow_data
= events_request
->viewer_data
;
1994 Drawing_t
*drawing
= control_flow_data
->drawing
;
1996 LttvTracefileContext
*tfc
= (LttvTracefileContext
*)call_data
;
1998 LttvTracefileState
*tfs
= (LttvTracefileState
*)call_data
;
1999 LttvTraceState
*ts
=(LttvTraceState
*)((LttvTracefileContext
*)tfs
)->t_context
;
2004 LttTime evtime
= ltt_event_time(e
);
2005 guint width
= drawing
->width
;
2007 /* we are in a execmode, before the state update. We must draw the
2008 * items corresponding to the state before it changes : now is the right
2012 LttvProcessState
*process
= tfs
->process
;
2013 g_assert(process
!= NULL
);
2015 guint pid
= process
->pid
;
2017 /* Well, the process_out existed : we must get it in the process hash
2018 * or add it, and draw its items.
2020 /* Add process to process list (if not present) */
2021 guint y
= 0, height
= 0, pl_height
= 0;
2022 HashedProcessData
*hashed_process_data
= NULL
;
2023 ProcessList
*process_list
= control_flow_data
->process_list
;
2024 LttTime birth
= process
->creation_time
;
2026 if(process_list
->current_hash_data
[tfc
->index
] != NULL
) {
2027 hashed_process_data
= process_list
->current_hash_data
[tfc
->index
];
2029 hashed_process_data
= processlist_get_process_data(process_list
,
2031 process
->last_cpu_index
,
2033 tfc
->t_context
->index
);
2034 if(hashed_process_data
== NULL
)
2036 g_assert(pid
== 0 || pid
!= process
->ppid
);
2037 ProcessInfo
*process_info
;
2038 /* Process not present */
2039 const gchar
*name
= g_quark_to_string(process
->name
);
2040 processlist_add(process_list
,
2042 process
->last_cpu_index
,
2045 tfc
->t_context
->index
,
2049 &hashed_process_data
);
2050 processlist_get_pixels_from_data(process_list
,
2051 hashed_process_data
,
2054 drawing_insert_square( drawing
, y
, height
);
2056 /* Set the current process */
2057 process_list
->current_hash_data
[process
->last_cpu_index
] =
2058 hashed_process_data
;
2061 /* Now, the process is in the state hash and our own process hash.
2062 * We definitely can draw the items related to the ending state.
2065 /* Check if the x position is unset. In can have been left unset by
2066 * a draw closure from a after chunk hook. This should never happen,
2067 * because it must be set by before chunk hook to the damage_begin
2070 g_assert(hashed_process_data
->x
.over
!= -1);
2072 if(ltt_time_compare(hashed_process_data
->next_good_time
,
2075 if(hashed_process_data
->x
.middle_marked
== FALSE
) {
2076 processlist_get_pixels_from_data(process_list
,
2077 hashed_process_data
,
2080 TimeWindow time_window
=
2081 lttvwindow_get_time_window(control_flow_data
->tab
);
2084 if(ltt_time_compare(evtime
, time_window
.start_time
) == -1
2085 || ltt_time_compare(evtime
, time_window
.end_time
) == 1)
2087 #endif //EXTRA_CHECK
2089 convert_time_to_pixels(
2095 /* Draw collision indicator */
2096 gdk_gc_set_foreground(drawing
->gc
, &drawing_colors
[COL_WHITE
]);
2097 gdk_draw_point(drawing
->pixmap
,
2101 hashed_process_data
->x
.middle_marked
= TRUE
;
2104 processlist_get_pixels_from_data(process_list
,
2105 hashed_process_data
,
2108 TimeWindow time_window
=
2109 lttvwindow_get_time_window(control_flow_data
->tab
);
2112 if(ltt_time_compare(evtime
, time_window
.start_time
) == -1
2113 || ltt_time_compare(evtime
, time_window
.end_time
) == 1)
2115 #endif //EXTRA_CHECK
2118 convert_time_to_pixels(
2125 /* Jump over draw if we are at the same x position */
2126 if(x
== hashed_process_data
->x
.middle
&&
2127 hashed_process_data
->x
.middle_used
)
2129 if(hashed_process_data
->x
.middle_marked
== FALSE
) {
2130 /* Draw collision indicator */
2131 gdk_gc_set_foreground(drawing
->gc
, &drawing_colors
[COL_WHITE
]);
2132 gdk_draw_point(drawing
->pixmap
,
2136 hashed_process_data
->x
.middle_marked
= TRUE
;
2141 DrawContext draw_context
;
2142 /* Now create the drawing context that will be used to draw
2143 * items related to the last state. */
2144 draw_context
.drawable
= drawing
->pixmap
;
2145 draw_context
.gc
= drawing
->gc
;
2146 draw_context
.pango_layout
= drawing
->pango_layout
;
2147 draw_context
.drawinfo
.start
.x
= hashed_process_data
->x
.middle
;
2148 draw_context
.drawinfo
.end
.x
= x
;
2150 draw_context
.drawinfo
.y
.over
= y
+1;
2151 draw_context
.drawinfo
.y
.middle
= y
+(height
/2);
2152 draw_context
.drawinfo
.y
.under
= y
+height
;
2154 draw_context
.drawinfo
.start
.offset
.over
= 0;
2155 draw_context
.drawinfo
.start
.offset
.middle
= 0;
2156 draw_context
.drawinfo
.start
.offset
.under
= 0;
2157 draw_context
.drawinfo
.end
.offset
.over
= 0;
2158 draw_context
.drawinfo
.end
.offset
.middle
= 0;
2159 draw_context
.drawinfo
.end
.offset
.under
= 0;
2163 PropertiesLine prop_line
= prepare_s_e_line(process
);
2164 draw_line((void*)&prop_line
, (void*)&draw_context
);
2167 /* become the last x position */
2168 hashed_process_data
->x
.middle
= x
;
2169 hashed_process_data
->x
.middle_used
= TRUE
;
2170 hashed_process_data
->x
.middle_marked
= FALSE
;
2172 /* Calculate the next good time */
2173 convert_pixels_to_time(width
, x
+1, time_window
,
2174 &hashed_process_data
->next_good_time
);
2181 /* after_execmode_hook
2183 * The draw after hook is called by the reading API to have a
2184 * particular event drawn on the screen.
2185 * @param hook_data ControlFlowData structure of the viewer.
2186 * @param call_data Event context.
2188 * This function adds items to be drawn in a queue for each process.
2191 int after_execmode_hook(void *hook_data
, void *call_data
)
2193 /**************** DOES NOTHING!! *************/
2194 /* hook desactivated in drawing.c */
2199 EventsRequest
*events_request
= (EventsRequest
*)hook_data
;
2200 ControlFlowData
*control_flow_data
= events_request
->viewer_data
;
2202 LttvTracefileContext
*tfc
= (LttvTracefileContext
*)call_data
;
2204 LttvTracefileState
*tfs
= (LttvTracefileState
*)call_data
;
2205 LttvTraceState
*ts
=(LttvTraceState
*)((LttvTracefileContext
*)tfs
)->t_context
;
2210 LttTime evtime
= ltt_event_time(e
);
2211 guint width
= control_flow_data
->drawing
->width
;
2213 /* Add process to process list (if not present) */
2214 LttvProcessState
*process
;
2216 guint y
= 0, height
= 0, pl_height
= 0;
2217 HashedProcessData
*hashed_process_data
= NULL
;
2219 ProcessList
*process_list
= control_flow_data
->process_list
;
2221 /* Find process pid_in in the list... */
2222 process
= tfs
->process
;
2223 /* It should exist, because we are after the state update. */
2224 g_assert(process
!= NULL
);
2226 guint pid
= process
->pid
;
2228 birth
= process
->creation_time
;
2230 if(process_list
->current_hash_data
[tfc
->index
] != NULL
) {
2231 hashed_process_data
= process_list
->current_hash_data
[tfc
->index
];
2233 hashed_process_data
= processlist_get_process_data(process_list
,
2235 process
->last_cpu_index
,
2237 tfc
->t_context
->index
);
2238 if(hashed_process_data
== NULL
)
2240 g_assert(pid
== 0 || pid
!= process
->ppid
);
2241 /* Process not present */
2242 const gchar
*name
= g_quark_to_string(process
->name
);
2243 ProcessInfo
*process_info
;
2244 processlist_add(process_list
,
2246 process
->last_cpu_index
,
2249 tfc
->t_context
->index
,
2253 &hashed_process_data
);
2254 processlist_get_pixels_from_data(process_list
,
2255 hashed_process_data
,
2258 drawing_insert_square( control_flow_data
->drawing
, y
, height
);
2260 /* Set the current process */
2261 process_list
->current_hash_data
[process
->last_cpu_index
] =
2262 hashed_process_data
;
2265 if(ltt_time_compare(hashed_process_data
->next_good_time
,
2269 processlist_get_pixels_from_data(process_list
,
2270 hashed_process_data
,
2274 TimeWindow time_window
=
2275 lttvwindow_get_time_window(control_flow_data
->tab
);
2278 if(ltt_time_compare(evtime
, time_window
.start_time
) == -1
2279 || ltt_time_compare(evtime
, time_window
.end_time
) == 1)
2281 #endif //EXTRA_CHECK
2286 convert_time_to_pixels(
2292 if(hashed_process_data
->x
.middle
!= new_x
) {
2293 hashed_process_data
->x
.middle
= new_x
;
2294 hashed_process_data
->x
.middle_used
= FALSE
;
2295 hashed_process_data
->x
.middle_marked
= FALSE
;
2303 /* before_process_hook
2305 * Draw lines for process event.
2307 * @param hook_data ControlFlowData structure of the viewer.
2308 * @param call_data Event context.
2310 * This function adds items to be drawn in a queue for each process.
2313 int before_process_hook(void *hook_data
, void *call_data
)
2315 EventsRequest
*events_request
= (EventsRequest
*)hook_data
;
2316 ControlFlowData
*control_flow_data
= events_request
->viewer_data
;
2317 Drawing_t
*drawing
= control_flow_data
->drawing
;
2319 LttvTracefileContext
*tfc
= (LttvTracefileContext
*)call_data
;
2321 LttvTracefileState
*tfs
= (LttvTracefileState
*)call_data
;
2322 LttvTraceState
*ts
=(LttvTraceState
*)((LttvTracefileContext
*)tfs
)->t_context
;
2327 LttTime evtime
= ltt_event_time(e
);
2328 guint width
= control_flow_data
->drawing
->width
;
2332 LttField
*f
= ltt_event_field(e
);
2334 element
= ltt_field_member(f
,0);
2335 sub_id
= ltt_event_get_long_unsigned(e
,element
);
2338 if(sub_id
== 3) { /* exit */
2340 /* Add process to process list (if not present) */
2341 LttvProcessState
*process
= tfs
->process
;
2342 guint pid
= process
->pid
;
2344 guint y
= 0, height
= 0, pl_height
= 0;
2345 HashedProcessData
*hashed_process_data
= NULL
;
2347 ProcessList
*process_list
= control_flow_data
->process_list
;
2349 g_assert(process
!= NULL
);
2351 birth
= process
->creation_time
;
2353 if(process_list
->current_hash_data
[tfc
->index
] != NULL
) {
2354 hashed_process_data
= process_list
->current_hash_data
[tfc
->index
];
2356 hashed_process_data
= processlist_get_process_data(process_list
,
2358 process
->last_cpu_index
,
2360 tfc
->t_context
->index
);
2361 if(hashed_process_data
== NULL
)
2363 g_assert(pid
== 0 || pid
!= process
->ppid
);
2364 /* Process not present */
2365 const gchar
*name
= g_quark_to_string(process
->name
);
2366 ProcessInfo
*process_info
;
2367 processlist_add(process_list
,
2369 process
->last_cpu_index
,
2372 tfc
->t_context
->index
,
2376 &hashed_process_data
);
2377 processlist_get_pixels_from_data(process_list
,
2378 hashed_process_data
,
2381 drawing_insert_square( control_flow_data
->drawing
, y
, height
);
2385 /* Now, the process is in the state hash and our own process hash.
2386 * We definitely can draw the items related to the ending state.
2389 /* Check if the x position is unset. In can have been left unset by
2390 * a draw closure from a after chunk hook. This should never happen,
2391 * because it must be set by before chunk hook to the damage_begin
2394 g_assert(hashed_process_data
->x
.over
!= -1);
2396 if(ltt_time_compare(hashed_process_data
->next_good_time
,
2399 if(hashed_process_data
->x
.middle_marked
== FALSE
) {
2400 processlist_get_pixels_from_data(process_list
,
2401 hashed_process_data
,
2404 TimeWindow time_window
=
2405 lttvwindow_get_time_window(control_flow_data
->tab
);
2408 if(ltt_time_compare(evtime
, time_window
.start_time
) == -1
2409 || ltt_time_compare(evtime
, time_window
.end_time
) == 1)
2411 #endif //EXTRA_CHECK
2414 convert_time_to_pixels(
2420 /* Draw collision indicator */
2421 gdk_gc_set_foreground(drawing
->gc
, &drawing_colors
[COL_WHITE
]);
2422 gdk_draw_point(drawing
->pixmap
,
2426 hashed_process_data
->x
.middle_marked
= TRUE
;
2429 processlist_get_pixels_from_data(process_list
,
2430 hashed_process_data
,
2433 TimeWindow time_window
=
2434 lttvwindow_get_time_window(control_flow_data
->tab
);
2437 if(ltt_time_compare(evtime
, time_window
.start_time
) == -1
2438 || ltt_time_compare(evtime
, time_window
.end_time
) == 1)
2440 #endif //EXTRA_CHECK
2444 convert_time_to_pixels(
2451 /* Jump over draw if we are at the same x position */
2452 if(x
== hashed_process_data
->x
.middle
&&
2453 hashed_process_data
->x
.middle_used
)
2455 if(hashed_process_data
->x
.middle_marked
== FALSE
) {
2456 /* Draw collision indicator */
2457 gdk_gc_set_foreground(drawing
->gc
, &drawing_colors
[COL_WHITE
]);
2458 gdk_draw_point(drawing
->pixmap
,
2462 hashed_process_data
->x
.middle_marked
= TRUE
;
2466 DrawContext draw_context
;
2468 /* Now create the drawing context that will be used to draw
2469 * items related to the last state. */
2470 draw_context
.drawable
= drawing
->pixmap
;
2471 draw_context
.gc
= drawing
->gc
;
2472 draw_context
.pango_layout
= drawing
->pango_layout
;
2473 draw_context
.drawinfo
.start
.x
= hashed_process_data
->x
.middle
;
2474 draw_context
.drawinfo
.end
.x
= x
;
2476 draw_context
.drawinfo
.y
.over
= y
+1;
2477 draw_context
.drawinfo
.y
.middle
= y
+(height
/2);
2478 draw_context
.drawinfo
.y
.under
= y
+height
;
2480 draw_context
.drawinfo
.start
.offset
.over
= 0;
2481 draw_context
.drawinfo
.start
.offset
.middle
= 0;
2482 draw_context
.drawinfo
.start
.offset
.under
= 0;
2483 draw_context
.drawinfo
.end
.offset
.over
= 0;
2484 draw_context
.drawinfo
.end
.offset
.middle
= 0;
2485 draw_context
.drawinfo
.end
.offset
.under
= 0;
2489 PropertiesLine prop_line
= prepare_s_e_line(process
);
2490 draw_line((void*)&prop_line
, (void*)&draw_context
);
2493 /* become the last x position */
2494 hashed_process_data
->x
.middle
= x
;
2495 hashed_process_data
->x
.middle_used
= TRUE
;
2496 hashed_process_data
->x
.middle_marked
= FALSE
;
2498 /* Calculate the next good time */
2499 convert_pixels_to_time(width
, x
+1, time_window
,
2500 &hashed_process_data
->next_good_time
);
2514 /* after_process_hook
2516 * Create the processlist entry for the child process. Put the last
2517 * position in x at the current time value.
2519 * @param hook_data ControlFlowData structure of the viewer.
2520 * @param call_data Event context.
2522 * This function adds items to be drawn in a queue for each process.
2525 int after_process_hook(void *hook_data
, void *call_data
)
2527 EventsRequest
*events_request
= (EventsRequest
*)hook_data
;
2528 ControlFlowData
*control_flow_data
= events_request
->viewer_data
;
2530 LttvTracefileContext
*tfc
= (LttvTracefileContext
*)call_data
;
2532 LttvTracefileState
*tfs
= (LttvTracefileState
*)call_data
;
2533 LttvTraceState
*ts
=(LttvTraceState
*)((LttvTracefileContext
*)tfs
)->t_context
;
2538 LttTime evtime
= ltt_event_time(e
);
2539 guint width
= control_flow_data
->drawing
->width
;
2544 LttField
*f
= ltt_event_field(e
);
2546 element
= ltt_field_member(f
,0);
2547 sub_id
= ltt_event_get_long_unsigned(e
,element
);
2548 element
= ltt_field_member(f
,1);
2549 param1
= ltt_event_get_long_unsigned(e
,element
);
2552 if(sub_id
== 2) { /* fork */
2554 guint child_pid
= param1
;
2555 /* Add process to process list (if not present) */
2556 LttvProcessState
*process_child
;
2558 guint y_child
= 0, height
= 0, pl_height
= 0;
2559 HashedProcessData
*hashed_process_data_child
= NULL
;
2561 ProcessList
*process_list
= control_flow_data
->process_list
;
2563 /* Find child in the list... */
2564 process_child
= lttv_state_find_process(tfs
, child_pid
);
2565 /* It should exist, because we are after the state update. */
2566 g_assert(process_child
!= NULL
);
2568 birth
= process_child
->creation_time
;
2570 hashed_process_data_child
= processlist_get_process_data(process_list
,
2572 process_child
->last_cpu_index
,
2574 tfc
->t_context
->index
);
2575 if(hashed_process_data_child
== NULL
)
2577 g_assert(child_pid
== 0 || child_pid
!= process_child
->ppid
);
2578 /* Process not present */
2579 const gchar
*name
= g_quark_to_string(process_child
->name
);
2580 ProcessInfo
*process_info
;
2581 processlist_add(process_list
,
2583 process_child
->last_cpu_index
,
2584 process_child
->ppid
,
2586 tfc
->t_context
->index
,
2590 &hashed_process_data_child
);
2591 processlist_get_pixels_from_data(process_list
,
2592 hashed_process_data_child
,
2595 drawing_insert_square( control_flow_data
->drawing
, y_child
, height
);
2599 if(ltt_time_compare(hashed_process_data_child
->next_good_time
,
2603 processlist_get_pixels_from_data(process_list
,
2604 hashed_process_data_child
,
2608 TimeWindow time_window
=
2609 lttvwindow_get_time_window(control_flow_data
->tab
);
2612 if(ltt_time_compare(evtime
, time_window
.start_time
) == -1
2613 || ltt_time_compare(evtime
, time_window
.end_time
) == 1)
2615 #endif //EXTRA_CHECK
2618 convert_time_to_pixels(
2624 if(hashed_process_data_child
->x
.over
!= new_x
) {
2625 hashed_process_data_child
->x
.over
= new_x
;
2626 hashed_process_data_child
->x
.over_used
= FALSE
;
2627 hashed_process_data_child
->x
.over_marked
= FALSE
;
2629 if(hashed_process_data_child
->x
.middle
!= new_x
) {
2630 hashed_process_data_child
->x
.middle
= new_x
;
2631 hashed_process_data_child
->x
.middle_used
= FALSE
;
2632 hashed_process_data_child
->x
.middle_marked
= FALSE
;
2634 if(hashed_process_data_child
->x
.under
!= new_x
) {
2635 hashed_process_data_child
->x
.under
= new_x
;
2636 hashed_process_data_child
->x
.under_used
= FALSE
;
2637 hashed_process_data_child
->x
.under_marked
= FALSE
;
2641 } else if(sub_id
== 3) { /* exit */
2643 /* Add process to process list (if not present) */
2644 LttvProcessState
*process
= tfs
->process
;
2645 guint pid
= process
->pid
;
2647 guint y
= 0, height
= 0, pl_height
= 0;
2648 HashedProcessData
*hashed_process_data
= NULL
;
2650 ProcessList
*process_list
= control_flow_data
->process_list
;
2652 /* It should exist, because we are after the state update. */
2653 g_assert(process
!= NULL
);
2655 birth
= process
->creation_time
;
2657 if(process_list
->current_hash_data
[tfc
->index
] != NULL
) {
2658 hashed_process_data
= process_list
->current_hash_data
[tfc
->index
];
2660 hashed_process_data
= processlist_get_process_data(process_list
,
2662 process
->last_cpu_index
,
2664 tfc
->t_context
->index
);
2665 if(hashed_process_data
== NULL
)
2667 g_assert(pid
== 0 || pid
!= process
->ppid
);
2668 /* Process not present */
2669 const gchar
*name
= g_quark_to_string(process
->name
);
2670 ProcessInfo
*process_info
;
2671 processlist_add(process_list
,
2673 process
->last_cpu_index
,
2676 tfc
->t_context
->index
,
2680 &hashed_process_data
);
2681 processlist_get_pixels_from_data(process_list
,
2682 hashed_process_data
,
2685 drawing_insert_square( control_flow_data
->drawing
, y
, height
);
2688 /* Set the current process */
2689 process_list
->current_hash_data
[process
->last_cpu_index
] =
2690 hashed_process_data
;
2693 if(ltt_time_compare(hashed_process_data
->next_good_time
,
2697 processlist_get_pixels_from_data(process_list
,
2698 hashed_process_data
,
2702 TimeWindow time_window
=
2703 lttvwindow_get_time_window(control_flow_data
->tab
);
2706 if(ltt_time_compare(evtime
, time_window
.start_time
) == -1
2707 || ltt_time_compare(evtime
, time_window
.end_time
) == 1)
2709 #endif //EXTRA_CHECK
2712 convert_time_to_pixels(
2717 if(hashed_process_data
->x
.middle
!= new_x
) {
2718 hashed_process_data
->x
.middle
= new_x
;
2719 hashed_process_data
->x
.middle_used
= FALSE
;
2720 hashed_process_data
->x
.middle_marked
= FALSE
;
2730 gint
update_time_window_hook(void *hook_data
, void *call_data
)
2732 ControlFlowData
*control_flow_data
= (ControlFlowData
*) hook_data
;
2733 Drawing_t
*drawing
= control_flow_data
->drawing
;
2735 const TimeWindowNotifyData
*time_window_nofify_data
=
2736 ((const TimeWindowNotifyData
*)call_data
);
2738 TimeWindow
*old_time_window
=
2739 time_window_nofify_data
->old_time_window
;
2740 TimeWindow
*new_time_window
=
2741 time_window_nofify_data
->new_time_window
;
2743 /* Update the ruler */
2744 drawing_update_ruler(control_flow_data
->drawing
,
2748 /* Two cases : zoom in/out or scrolling */
2750 /* In order to make sure we can reuse the old drawing, the scale must
2751 * be the same and the new time interval being partly located in the
2752 * currently shown time interval. (reuse is only for scrolling)
2755 g_info("Old time window HOOK : %u, %u to %u, %u",
2756 old_time_window
->start_time
.tv_sec
,
2757 old_time_window
->start_time
.tv_nsec
,
2758 old_time_window
->time_width
.tv_sec
,
2759 old_time_window
->time_width
.tv_nsec
);
2761 g_info("New time window HOOK : %u, %u to %u, %u",
2762 new_time_window
->start_time
.tv_sec
,
2763 new_time_window
->start_time
.tv_nsec
,
2764 new_time_window
->time_width
.tv_sec
,
2765 new_time_window
->time_width
.tv_nsec
);
2767 if( new_time_window
->time_width
.tv_sec
== old_time_window
->time_width
.tv_sec
2768 && new_time_window
->time_width
.tv_nsec
== old_time_window
->time_width
.tv_nsec
)
2770 /* Same scale (scrolling) */
2771 g_info("scrolling");
2772 LttTime
*ns
= &new_time_window
->start_time
;
2773 LttTime
*nw
= &new_time_window
->time_width
;
2774 LttTime
*os
= &old_time_window
->start_time
;
2775 LttTime
*ow
= &old_time_window
->time_width
;
2776 LttTime old_end
= old_time_window
->end_time
;
2777 LttTime new_end
= new_time_window
->end_time
;
2779 //if(ns<os+w && os+w<ns+w)
2780 //if(ns<old_end && os<ns)
2781 if(ltt_time_compare(*ns
, old_end
) == -1
2782 && ltt_time_compare(*os
, *ns
) == -1)
2784 g_info("scrolling near right");
2785 /* Scroll right, keep right part of the screen */
2787 guint width
= control_flow_data
->drawing
->width
;
2788 convert_time_to_pixels(
2794 /* Copy old data to new location */
2795 gdk_draw_drawable (control_flow_data
->drawing
->pixmap
,
2796 control_flow_data
->drawing
->drawing_area
->style
->black_gc
,
2797 control_flow_data
->drawing
->pixmap
,
2800 control_flow_data
->drawing
->width
-x
+SAFETY
, -1);
2802 if(drawing
->damage_begin
== drawing
->damage_end
)
2803 drawing
->damage_begin
= control_flow_data
->drawing
->width
-x
;
2805 drawing
->damage_begin
= 0;
2807 drawing
->damage_end
= control_flow_data
->drawing
->width
;
2809 /* Clear the data request background, but not SAFETY */
2810 gdk_draw_rectangle (control_flow_data
->drawing
->pixmap
,
2811 //control_flow_data->drawing->drawing_area->style->black_gc,
2812 control_flow_data
->drawing
->drawing_area
->style
->black_gc
,
2814 drawing
->damage_begin
+SAFETY
, 0,
2815 drawing
->damage_end
- drawing
->damage_begin
, // do not overlap
2816 control_flow_data
->drawing
->height
);
2818 gtk_widget_queue_draw_area (drawing
->drawing_area
,
2820 control_flow_data
->drawing
->width
,
2821 control_flow_data
->drawing
->height
);
2823 /* Get new data for the rest. */
2824 drawing_data_request(control_flow_data
->drawing
,
2825 &control_flow_data
->drawing
->pixmap
,
2826 drawing
->damage_begin
, 0,
2827 drawing
->damage_end
- drawing
->damage_begin
,
2828 control_flow_data
->drawing
->height
);
2831 //if(ns<os && os<ns+w)
2832 //if(ns<os && os<new_end)
2833 if(ltt_time_compare(*ns
,*os
) == -1
2834 && ltt_time_compare(*os
,new_end
) == -1)
2836 g_info("scrolling near left");
2837 /* Scroll left, keep left part of the screen */
2839 guint width
= control_flow_data
->drawing
->width
;
2840 convert_time_to_pixels(
2847 /* Copy old data to new location */
2848 gdk_draw_drawable (control_flow_data
->drawing
->pixmap
,
2849 control_flow_data
->drawing
->drawing_area
->style
->black_gc
,
2850 control_flow_data
->drawing
->pixmap
,
2855 if(drawing
->damage_begin
== drawing
->damage_end
)
2856 drawing
->damage_end
= x
;
2858 drawing
->damage_end
=
2859 control_flow_data
->drawing
->width
;
2861 drawing
->damage_begin
= 0;
2863 gdk_draw_rectangle (control_flow_data
->drawing
->pixmap
,
2864 control_flow_data
->drawing
->drawing_area
->style
->black_gc
,
2866 drawing
->damage_begin
, 0,
2867 drawing
->damage_end
- drawing
->damage_begin
, // do not overlap
2868 control_flow_data
->drawing
->height
);
2870 gtk_widget_queue_draw_area (drawing
->drawing_area
,
2872 control_flow_data
->drawing
->width
,
2873 control_flow_data
->drawing
->height
);
2876 /* Get new data for the rest. */
2877 drawing_data_request(control_flow_data
->drawing
,
2878 &control_flow_data
->drawing
->pixmap
,
2879 drawing
->damage_begin
, 0,
2880 drawing
->damage_end
- drawing
->damage_begin
,
2881 control_flow_data
->drawing
->height
);
2884 if(ltt_time_compare(*ns
,*os
) == 0)
2886 g_info("not scrolling");
2888 g_info("scrolling far");
2889 /* Cannot reuse any part of the screen : far jump */
2892 gdk_draw_rectangle (control_flow_data
->drawing
->pixmap
,
2893 control_flow_data
->drawing
->drawing_area
->style
->black_gc
,
2896 control_flow_data
->drawing
->width
+SAFETY
, // do not overlap
2897 control_flow_data
->drawing
->height
);
2899 gtk_widget_queue_draw_area (drawing
->drawing_area
,
2901 control_flow_data
->drawing
->width
,
2902 control_flow_data
->drawing
->height
);
2904 drawing
->damage_begin
= 0;
2905 drawing
->damage_end
= control_flow_data
->drawing
->width
;
2907 drawing_data_request(control_flow_data
->drawing
,
2908 &control_flow_data
->drawing
->pixmap
,
2910 control_flow_data
->drawing
->width
,
2911 control_flow_data
->drawing
->height
);
2917 /* Different scale (zoom) */
2920 gdk_draw_rectangle (control_flow_data
->drawing
->pixmap
,
2921 control_flow_data
->drawing
->drawing_area
->style
->black_gc
,
2924 control_flow_data
->drawing
->width
+SAFETY
, // do not overlap
2925 control_flow_data
->drawing
->height
);
2927 gtk_widget_queue_draw_area (drawing
->drawing_area
,
2929 control_flow_data
->drawing
->width
,
2930 control_flow_data
->drawing
->height
);
2932 drawing
->damage_begin
= 0;
2933 drawing
->damage_end
= control_flow_data
->drawing
->width
;
2935 drawing_data_request(control_flow_data
->drawing
,
2936 &control_flow_data
->drawing
->pixmap
,
2938 control_flow_data
->drawing
->width
,
2939 control_flow_data
->drawing
->height
);
2947 gint
traceset_notify(void *hook_data
, void *call_data
)
2949 ControlFlowData
*control_flow_data
= (ControlFlowData
*) hook_data
;
2950 Drawing_t
*drawing
= control_flow_data
->drawing
;
2951 GtkWidget
*widget
= drawing
->drawing_area
;
2954 drawing_clear(control_flow_data
->drawing
);
2955 processlist_clear(control_flow_data
->process_list
);
2956 redraw_notify(control_flow_data
, NULL
);
2958 request_background_data(control_flow_data
);
2960 drawing
->damage_begin
= 0;
2961 drawing
->damage_end
= drawing
->width
;
2962 if(drawing
->damage_begin
< drawing
->damage_end
)
2964 drawing_data_request(drawing
,
2966 drawing
->damage_begin
,
2968 drawing
->damage_end
-drawing
->damage_begin
,
2972 gtk_widget_queue_draw_area(drawing
->drawing_area
,
2981 gint
redraw_notify(void *hook_data
, void *call_data
)
2983 ControlFlowData
*control_flow_data
= (ControlFlowData
*) hook_data
;
2984 Drawing_t
*drawing
= control_flow_data
->drawing
;
2985 GtkWidget
*widget
= drawing
->drawing_area
;
2987 drawing
->damage_begin
= 0;
2988 drawing
->damage_end
= drawing
->width
;
2990 /* fun feature, to be separated someday... */
2991 drawing_clear(control_flow_data
->drawing
);
2992 processlist_clear(control_flow_data
->process_list
);
2995 gdk_draw_rectangle (drawing
->pixmap
,
2996 widget
->style
->black_gc
,
2999 drawing
->width
+SAFETY
,
3003 if(drawing
->damage_begin
< drawing
->damage_end
)
3005 drawing_data_request(drawing
,
3007 drawing
->damage_begin
,
3009 drawing
->damage_end
-drawing
->damage_begin
,
3013 gtk_widget_queue_draw_area(drawing
->drawing_area
,
3022 gint
continue_notify(void *hook_data
, void *call_data
)
3024 ControlFlowData
*control_flow_data
= (ControlFlowData
*) hook_data
;
3025 Drawing_t
*drawing
= control_flow_data
->drawing
;
3026 GtkWidget
*widget
= drawing
->drawing_area
;
3028 //g_assert(widget->allocation.width == drawing->damage_end);
3030 if(drawing
->damage_begin
< drawing
->damage_end
)
3032 drawing_data_request(drawing
,
3034 drawing
->damage_begin
,
3036 drawing
->damage_end
-drawing
->damage_begin
,
3044 gint
update_current_time_hook(void *hook_data
, void *call_data
)
3046 ControlFlowData
*control_flow_data
= (ControlFlowData
*)hook_data
;
3047 Drawing_t
*drawing
= control_flow_data
->drawing
;
3049 LttTime current_time
= *((LttTime
*)call_data
);
3051 TimeWindow time_window
=
3052 lttvwindow_get_time_window(control_flow_data
->tab
);
3054 LttTime time_begin
= time_window
.start_time
;
3055 LttTime width
= time_window
.time_width
;
3058 guint64 time_ll
= ltt_time_to_uint64(width
);
3059 time_ll
= time_ll
>> 1; /* divide by two */
3060 half_width
= ltt_time_from_uint64(time_ll
);
3062 LttTime time_end
= ltt_time_add(time_begin
, width
);
3064 LttvTracesetContext
* tsc
=
3065 lttvwindow_get_traceset_context(control_flow_data
->tab
);
3067 LttTime trace_start
= tsc
->time_span
.start_time
;
3068 LttTime trace_end
= tsc
->time_span
.end_time
;
3070 g_info("New current time HOOK : %u, %u", current_time
.tv_sec
,
3071 current_time
.tv_nsec
);
3075 /* If current time is inside time interval, just move the highlight
3078 /* Else, we have to change the time interval. We have to tell it
3079 * to the main window. */
3080 /* The time interval change will take care of placing the current
3081 * time at the center of the visible area, or nearest possible if we are
3082 * at one end of the trace. */
3085 if(ltt_time_compare(current_time
, time_begin
) == -1)
3087 TimeWindow new_time_window
;
3089 if(ltt_time_compare(current_time
,
3090 ltt_time_add(trace_start
,half_width
)) == -1)
3091 time_begin
= trace_start
;
3093 time_begin
= ltt_time_sub(current_time
,half_width
);
3095 new_time_window
.start_time
= time_begin
;
3096 new_time_window
.time_width
= width
;
3097 new_time_window
.time_width_double
= ltt_time_to_double(width
);
3098 new_time_window
.end_time
= ltt_time_add(time_begin
, width
);
3100 lttvwindow_report_time_window(control_flow_data
->tab
, new_time_window
);
3102 else if(ltt_time_compare(current_time
, time_end
) == 1)
3104 TimeWindow new_time_window
;
3106 if(ltt_time_compare(current_time
, ltt_time_sub(trace_end
, half_width
)) == 1)
3107 time_begin
= ltt_time_sub(trace_end
,width
);
3109 time_begin
= ltt_time_sub(current_time
,half_width
);
3111 new_time_window
.start_time
= time_begin
;
3112 new_time_window
.time_width
= width
;
3113 new_time_window
.time_width_double
= ltt_time_to_double(width
);
3114 new_time_window
.end_time
= ltt_time_add(time_begin
, width
);
3116 lttvwindow_report_time_window(control_flow_data
->tab
, new_time_window
);
3119 //gtk_widget_queue_draw(control_flow_data->drawing->drawing_area);
3120 gtk_widget_queue_draw_area(drawing
->drawing_area
,
3128 typedef struct _ClosureData
{
3129 EventsRequest
*events_request
;
3130 LttvTracesetState
*tss
;
3135 void draw_closure(gpointer key
, gpointer value
, gpointer user_data
)
3137 ProcessInfo
*process_info
= (ProcessInfo
*)key
;
3138 HashedProcessData
*hashed_process_data
= (HashedProcessData
*)value
;
3139 ClosureData
*closure_data
= (ClosureData
*)user_data
;
3141 EventsRequest
*events_request
= closure_data
->events_request
;
3142 ControlFlowData
*control_flow_data
= events_request
->viewer_data
;
3143 Drawing_t
*drawing
= control_flow_data
->drawing
;
3145 LttvTracesetState
*tss
= closure_data
->tss
;
3146 LttvTracesetContext
*tsc
= (LttvTracesetContext
*)closure_data
->tss
;
3148 LttTime evtime
= closure_data
->end_time
;
3149 guint width
= drawing
->width
;
3152 /* For the process */
3153 /* First, check if the current process is in the state computation
3154 * process list. If it is there, that means we must add it right now and
3155 * draw items from the beginning of the read for it. If it is not
3156 * present, it's a new process and it was not present : it will
3157 * be added after the state update. */
3159 g_assert(lttv_traceset_number(tsc
->ts
) > 0);
3160 #endif //EXTRA_CHECK
3161 /* tracefiles[0] is ok here, because we draw for every PID, and
3162 * assume CPU 0 for PID 0 //FIXME */
3163 LttvTracefileState
*tfs
=
3164 (LttvTracefileState
*)tsc
->traces
[process_info
->trace_num
]->tracefiles
[0];
3166 LttvProcessState
*process
;
3167 process
= lttv_state_find_process(tfs
,
3170 if(process
!= NULL
) {
3172 /* Only draw for processes that are currently in the trace states */
3174 guint y
= 0, height
= 0, pl_height
= 0;
3175 ProcessList
*process_list
= control_flow_data
->process_list
;
3176 LttTime birth
= process_info
->birth
;
3178 /* Should be alike when background info is ready */
3179 if(control_flow_data
->background_info_waiting
==0)
3180 g_assert(ltt_time_compare(process
->creation_time
,
3181 process_info
->birth
) == 0);
3182 /* process HAS to be present */
3183 processlist_get_pixels_from_data(process_list
,
3184 hashed_process_data
,
3188 /* Now, the process is in the state hash and our own process hash.
3189 * We definitely can draw the items related to the ending state.
3192 /* Check if the x position is unset. In can have been left unset by
3193 * a draw closure from a after chunk hook. This should never happen,
3194 * because it must be set by before chunk hook to the damage_begin
3197 g_assert(hashed_process_data
->x
.over
!= -1);
3199 if(ltt_time_compare(hashed_process_data
->next_good_time
,
3202 TimeWindow time_window
=
3203 lttvwindow_get_time_window(control_flow_data
->tab
);
3206 if(ltt_time_compare(evtime
, time_window
.start_time
) == -1
3207 || ltt_time_compare(evtime
, time_window
.end_time
) == 1)
3209 #endif //EXTRA_CHECK
3212 convert_time_to_pixels(
3218 DrawContext draw_context
;
3220 /* Now create the drawing context that will be used to draw
3221 * items related to the last state. */
3222 draw_context
.drawable
= drawing
->pixmap
;
3223 draw_context
.gc
= drawing
->gc
;
3224 draw_context
.pango_layout
= drawing
->pango_layout
;
3225 draw_context
.drawinfo
.end
.x
= x
;
3227 draw_context
.drawinfo
.y
.over
= y
+1;
3228 draw_context
.drawinfo
.y
.middle
= y
+(height
/2);
3229 draw_context
.drawinfo
.y
.under
= y
+height
;
3231 draw_context
.drawinfo
.start
.offset
.over
= 0;
3232 draw_context
.drawinfo
.start
.offset
.middle
= 0;
3233 draw_context
.drawinfo
.start
.offset
.under
= 0;
3234 draw_context
.drawinfo
.end
.offset
.over
= 0;
3235 draw_context
.drawinfo
.end
.offset
.middle
= 0;
3236 draw_context
.drawinfo
.end
.offset
.under
= 0;
3238 /* Jump over draw if we are at the same x position */
3239 if(x
== hashed_process_data
->x
.over
)
3243 draw_context
.drawinfo
.start
.x
= hashed_process_data
->x
.over
;
3245 PropertiesLine prop_line
= prepare_execmode_line(process
);
3246 draw_line((void*)&prop_line
, (void*)&draw_context
);
3248 hashed_process_data
->x
.over
= x
;
3252 if(x
== hashed_process_data
->x
.middle
&&
3253 hashed_process_data
->x
.middle_used
) {
3254 #if 0 /* do not mark closure : not missing information */
3255 if(hashed_process_data
->x
.middle_marked
== FALSE
) {
3256 /* Draw collision indicator */
3257 gdk_gc_set_foreground(drawing
->gc
, &drawing_colors
[COL_WHITE
]);
3258 gdk_draw_point(drawing
->pixmap
,
3262 hashed_process_data
->x
.middle_marked
= TRUE
;
3267 draw_context
.drawinfo
.start
.x
= hashed_process_data
->x
.middle
;
3269 PropertiesLine prop_line
= prepare_s_e_line(process
);
3270 draw_line((void*)&prop_line
, (void*)&draw_context
);
3272 /* become the last x position */
3273 if(x
!= hashed_process_data
->x
.middle
) {
3274 hashed_process_data
->x
.middle
= x
;
3275 /* but don't use the pixel */
3276 hashed_process_data
->x
.middle_used
= FALSE
;
3278 /* Calculate the next good time */
3279 convert_pixels_to_time(width
, x
+1, time_window
,
3280 &hashed_process_data
->next_good_time
);
3289 int before_chunk(void *hook_data
, void *call_data
)
3291 EventsRequest
*events_request
= (EventsRequest
*)hook_data
;
3292 LttvTracesetState
*tss
= (LttvTracesetState
*)call_data
;
3294 drawing_chunk_begin(events_request
, tss
);
3299 int before_request(void *hook_data
, void *call_data
)
3301 EventsRequest
*events_request
= (EventsRequest
*)hook_data
;
3302 LttvTracesetState
*tss
= (LttvTracesetState
*)call_data
;
3304 drawing_data_request_begin(events_request
, tss
);
3311 * after request is necessary in addition of after chunk in order to draw
3312 * lines until the end of the screen. after chunk just draws lines until
3319 int after_request(void *hook_data
, void *call_data
)
3321 EventsRequest
*events_request
= (EventsRequest
*)hook_data
;
3322 ControlFlowData
*control_flow_data
= events_request
->viewer_data
;
3323 LttvTracesetState
*tss
= (LttvTracesetState
*)call_data
;
3324 LttvTracesetContext
*tsc
= (LttvTracesetContext
*)call_data
;
3326 ProcessList
*process_list
= control_flow_data
->process_list
;
3327 LttTime end_time
= events_request
->end_time
;
3329 ClosureData closure_data
;
3330 closure_data
.events_request
= (EventsRequest
*)hook_data
;
3331 closure_data
.tss
= tss
;
3332 closure_data
.end_time
= end_time
;
3334 /* Draw last items */
3335 g_hash_table_foreach(process_list
->process_hash
, draw_closure
,
3336 (void*)&closure_data
);
3338 /* Request expose */
3339 drawing_request_expose(events_request
, tss
, end_time
);
3348 int after_chunk(void *hook_data
, void *call_data
)
3350 EventsRequest
*events_request
= (EventsRequest
*)hook_data
;
3351 ControlFlowData
*control_flow_data
= events_request
->viewer_data
;
3352 LttvTracesetState
*tss
= (LttvTracesetState
*)call_data
;
3353 LttvTracesetContext
*tsc
= (LttvTracesetContext
*)call_data
;
3354 LttvTracefileContext
*tfc
= lttv_traceset_context_get_current_tfc(tsc
);
3357 ProcessList
*process_list
= control_flow_data
->process_list
;
3359 g_free(process_list
->current_hash_data
);
3360 process_list
->current_hash_data
= NULL
;
3363 end_time
= LTT_TIME_MIN(tfc
->timestamp
, events_request
->end_time
);
3364 else /* end of traceset, or position now out of request : end */
3365 end_time
= events_request
->end_time
;
3367 ClosureData closure_data
;
3368 closure_data
.events_request
= (EventsRequest
*)hook_data
;
3369 closure_data
.tss
= tss
;
3370 closure_data
.end_time
= end_time
;
3372 /* Draw last items */
3373 g_hash_table_foreach(process_list
->process_hash
, draw_closure
,
3374 (void*)&closure_data
);
3376 /* Request expose */
3377 drawing_request_expose(events_request
, tss
, end_time
);