background_ready_hook);
control_flow_data->background_info_waiting++;
}
+ } else {
+ /* Data ready. Be its nature, this viewer doesn't need to have
+ * its data ready hook called htere, because a background
+ * request is always linked with a redraw.
+ */
}
+
}
lttv_hooks_destroy(background_ready_hook);
}
+/* Function that selects the color of status&exemode line */
+static __inline PropertiesLine prepare_s_e_line(LttvProcessState *process)
+{
+ PropertiesLine prop_line;
+ prop_line.line_width = 2;
+ prop_line.style = GDK_LINE_SOLID;
+ prop_line.y = MIDDLE;
+ //GdkColormap *colormap = gdk_colormap_get_system();
+
+ g_debug("prepare_status_line for state : %s",
+ g_quark_to_string(process->state->s));
+
+ if(process->state->s == LTTV_STATE_RUN) {
+ if(process->state->t == LTTV_STATE_USER_MODE)
+ prop_line.color = drawing_colors[COL_RUN_USER_MODE];
+ else if(process->state->t == LTTV_STATE_SYSCALL)
+ prop_line.color = drawing_colors[COL_RUN_SYSCALL];
+ else if(process->state->t == LTTV_STATE_TRAP)
+ prop_line.color = drawing_colors[COL_RUN_TRAP];
+ else if(process->state->t == LTTV_STATE_IRQ)
+ prop_line.color = drawing_colors[COL_RUN_IRQ];
+ else if(process->state->t == LTTV_STATE_MODE_UNKNOWN)
+ prop_line.color = drawing_colors[COL_MODE_UNKNOWN];
+ else
+ g_assert(FALSE); /* RUNNING MODE UNKNOWN */
+ } else if(process->state->s == LTTV_STATE_WAIT) {
+ /* We don't show if we wait while in user mode, trap, irq or syscall */
+ prop_line.color = drawing_colors[COL_WAIT];
+ } else if(process->state->s == LTTV_STATE_WAIT_CPU) {
+ /* We don't show if we wait for CPU while in user mode, trap, irq
+ * or syscall */
+ prop_line.color = drawing_colors[COL_WAIT_CPU];
+ } else if(process->state->s == LTTV_STATE_ZOMBIE) {
+ prop_line.color = drawing_colors[COL_ZOMBIE];
+ } else if(process->state->s == LTTV_STATE_WAIT_FORK) {
+ prop_line.color = drawing_colors[COL_WAIT_FORK];
+ } else if(process->state->s == LTTV_STATE_EXIT) {
+ prop_line.color = drawing_colors[COL_EXIT];
+ } else if(process->state->s == LTTV_STATE_UNNAMED) {
+ prop_line.color = drawing_colors[COL_UNNAMED];
+ } else
+ g_assert(FALSE); /* UNKNOWN STATE */
+
+ return prop_line;
+
+}
+#if 0
static __inline PropertiesLine prepare_status_line(LttvProcessState *process)
{
PropertiesLine prop_line;
prop_line.y = MIDDLE;
//GdkColormap *colormap = gdk_colormap_get_system();
- g_debug("prepare_status_line for state : %s", g_quark_to_string(process->state->s));
+ g_debug("prepare_status_line for state : %s",
+ g_quark_to_string(process->state->s));
/* color of line : status of the process */
if(process->state->s == LTTV_STATE_UNNAMED)
prop_line.color = drawing_colors[COL_WAIT_FORK];
else if(process->state->s == LTTV_STATE_WAIT_CPU)
prop_line.color = drawing_colors[COL_WAIT_CPU];
+ else if(process->state->s == LTTV_STATE_EXIT)
+ prop_line.color = drawing_colors[COL_EXIT];
else if(process->state->s == LTTV_STATE_ZOMBIE)
prop_line.color = drawing_colors[COL_ZOMBIE];
else if(process->state->s == LTTV_STATE_WAIT)
else if(process->state->s == LTTV_STATE_RUN)
prop_line.color = drawing_colors[COL_RUN];
else
- prop_line.color = drawing_colors[COL_WHITE];
+ prop_line.color = drawing_colors[COL_WHITE];
//gdk_colormap_alloc_color(colormap,
// prop_line.color,
return prop_line;
}
-
+#endif //0
/* before_schedchange_hook
if(ltt_time_compare(evtime, time_window.start_time) == -1
|| ltt_time_compare(evtime, end_time) == 1)
return;
-
guint width = drawing->width;
- if(strcmp(ltt_eventtype_name(ltt_event_eventtype(e)),"schedchange") == 0) {
-
- /* we are in a schedchange, before the state update. We must draw the
- * items corresponding to the state before it changes : now is the right
- * time to do it.
- */
+ /* we are in a schedchange, before the state update. We must draw the
+ * items corresponding to the state before it changes : now is the right
+ * time to do it.
+ */
- guint pid_out;
- guint pid_in;
- {
- LttField *f = ltt_event_field(e);
- LttField *element;
- element = ltt_field_member(f,0);
- pid_out = ltt_event_get_long_unsigned(e,element);
- element = ltt_field_member(f,1);
- pid_in = ltt_event_get_long_unsigned(e,element);
- g_debug("out : %u in : %u", pid_out, pid_in);
- }
+ guint pid_out;
+ guint pid_in;
+ {
+ LttField *f = ltt_event_field(e);
+ LttField *element;
+ element = ltt_field_member(f,0);
+ pid_out = ltt_event_get_long_unsigned(e,element);
+ element = ltt_field_member(f,1);
+ pid_in = ltt_event_get_long_unsigned(e,element);
+ g_debug("out : %u in : %u", pid_out, pid_in);
+ }
+
+ {
+ /* For the pid_out */
+ /* First, check if the current process is in the state computation
+ * process list. If it is there, that means we must add it right now and
+ * draw items from the beginning of the read for it. If it is not
+ * present, it's a new process and it was not present : it will
+ * be added after the state update. */
+ LttvProcessState *process;
+ process = lttv_state_find_process(tfs, pid_out);
- {
- /* For the pid_out */
- /* First, check if the current process is in the state computation
- * process list. If it is there, that means we must add it right now and
- * draw items from the beginning of the read for it. If it is not
- * present, it's a new process and it was not present : it will
- * be added after the state update. */
- LttvProcessState *process;
- process = lttv_state_find_process(tfs, pid_out);
+ if(process != NULL) {
+ /* Well, the process_out existed : we must get it in the process hash
+ * or add it, and draw its items.
+ */
+ /* Add process to process list (if not present) */
+ guint y = 0, height = 0, pl_height = 0;
+ HashedProcessData *hashed_process_data = NULL;
+ ProcessList *process_list =
+ guicontrolflow_get_process_list(control_flow_data);
+ LttTime birth = process->creation_time;
+ const gchar *name = g_quark_to_string(process->name);
- if(process != NULL) {
- /* Well, the process_out existed : we must get it in the process hash
- * or add it, and draw its items.
- */
- /* Add process to process list (if not present) */
- guint y = 0, height = 0, pl_height = 0;
- HashedProcessData *hashed_process_data = NULL;
- ProcessList *process_list =
- guicontrolflow_get_process_list(control_flow_data);
- LttTime birth = process->creation_time;
- const gchar *name = g_quark_to_string(process->name);
-
- if(processlist_get_process_pixels(process_list,
+ if(processlist_get_process_pixels(process_list,
+ pid_out,
+ process->last_cpu,
+ &birth,
+ tfc->t_context->index,
+ &y,
+ &height,
+ &hashed_process_data) == 1)
+ {
+ g_assert(pid_out == 0 || pid_out != process->ppid);
+ /* Process not present */
+ processlist_add(process_list,
+ pid_out,
+ process->last_cpu,
+ process->ppid,
+ &birth,
+ tfc->t_context->index,
+ name,
+ &pl_height,
+ &hashed_process_data);
+ processlist_get_process_pixels(process_list,
pid_out,
process->last_cpu,
&birth,
tfc->t_context->index,
&y,
&height,
- &hashed_process_data) == 1)
- {
- g_assert(pid_out == 0 || pid_out != process->ppid);
- /* Process not present */
- processlist_add(process_list,
- pid_out,
- process->last_cpu,
- process->ppid,
- &birth,
- tfc->t_context->index,
- name,
- &pl_height,
- &hashed_process_data);
- processlist_get_process_pixels(process_list,
- pid_out,
- process->last_cpu,
- &birth,
- tfc->t_context->index,
- &y,
- &height,
- &hashed_process_data);
- drawing_insert_square( drawing, y, height);
- }
+ &hashed_process_data);
+ drawing_insert_square( drawing, y, height);
+ }
+
+ /* Now, the process is in the state hash and our own process hash.
+ * We definitely can draw the items related to the ending state.
+ */
- /* Now, the process is in the state hash and our own process hash.
- * We definitely can draw the items related to the ending state.
- */
-
- /* Check if the x position is unset. In can have been left unset by
- * a draw closure from a after chunk hook. This should never happen,
- * because it must be set by before chunk hook to the damage_begin
- * value.
- */
- g_assert(hashed_process_data->x != -1);
+ /* Check if the x position is unset. In can have been left unset by
+ * a draw closure from a after chunk hook. This should never happen,
+ * because it must be set by before chunk hook to the damage_begin
+ * value.
+ */
+ g_assert(hashed_process_data->x.middle != -1);
+ {
+ guint x;
+ convert_time_to_pixels(
+ time_window.start_time,
+ end_time,
+ evtime,
+ width,
+ &x);
+
+
+ /* Jump over draw if we are at the same x position */
+ if(x == hashed_process_data->x.middle &&
+ hashed_process_data->x.middle_used)
{
- guint x;
+ if(hashed_process_data->x.middle_marked == FALSE) {
+ /* Draw collision indicator */
+ gdk_gc_set_foreground(drawing->gc, &drawing_colors[COL_WHITE]);
+ gdk_draw_point(drawing->pixmap,
+ drawing->gc,
+ x,
+ y+1);
+ }
+ /* jump */
+ } else {
DrawContext draw_context;
- convert_time_to_pixels(
- time_window.start_time,
- end_time,
- evtime,
- width,
- &x);
-
/* Now create the drawing context that will be used to draw
* items related to the last state. */
draw_context.drawable = drawing->pixmap;
draw_context.gc = drawing->gc;
draw_context.pango_layout = drawing->pango_layout;
- draw_context.drawinfo.start.x = hashed_process_data->x;
+ draw_context.drawinfo.start.x = hashed_process_data->x.middle;
draw_context.drawinfo.end.x = x;
- draw_context.drawinfo.y.over = y;
- draw_context.drawinfo.y.middle = y+(height/4);
- draw_context.drawinfo.y.under = y+(height/2)+2;
+ draw_context.drawinfo.y.over = y+1;
+ draw_context.drawinfo.y.middle = y+(height/2);
+ draw_context.drawinfo.y.under = y+height;
draw_context.drawinfo.start.offset.over = 0;
draw_context.drawinfo.start.offset.middle = 0;
{
/* Draw the line */
- PropertiesLine prop_line = prepare_status_line(process);
+ PropertiesLine prop_line = prepare_s_e_line(process);
draw_line((void*)&prop_line, (void*)&draw_context);
}
/* become the last x position */
- hashed_process_data->x = x;
+ hashed_process_data->x.middle = x;
+ hashed_process_data->x.middle_used = TRUE;
+ hashed_process_data->x.middle_marked = FALSE;
}
}
}
+ }
- {
- /* For the pid_in */
- /* First, check if the current process is in the state computation
- * process list. If it is there, that means we must add it right now and
- * draw items from the beginning of the read for it. If it is not
- * present, it's a new process and it was not present : it will
- * be added after the state update. */
- LttvProcessState *process;
- process = lttv_state_find_process(tfs, pid_in);
+ {
+ /* For the pid_in */
+ /* First, check if the current process is in the state computation
+ * process list. If it is there, that means we must add it right now and
+ * draw items from the beginning of the read for it. If it is not
+ * present, it's a new process and it was not present : it will
+ * be added after the state update. */
+ LttvProcessState *process;
+ process = lttv_state_find_process(tfs, pid_in);
+
+ if(process != NULL) {
+ /* Well, the process_out existed : we must get it in the process hash
+ * or add it, and draw its items.
+ */
+ /* Add process to process list (if not present) */
+ guint y = 0, height = 0, pl_height = 0;
+ HashedProcessData *hashed_process_data = NULL;
+ ProcessList *process_list =
+ guicontrolflow_get_process_list(control_flow_data);
+ LttTime birth = process->creation_time;
+ const gchar *name = g_quark_to_string(process->name);
- if(process != NULL) {
- /* Well, the process_out existed : we must get it in the process hash
- * or add it, and draw its items.
- */
- /* Add process to process list (if not present) */
- guint y = 0, height = 0, pl_height = 0;
- HashedProcessData *hashed_process_data = NULL;
- ProcessList *process_list =
- guicontrolflow_get_process_list(control_flow_data);
- LttTime birth = process->creation_time;
- const gchar *name = g_quark_to_string(process->name);
-
- if(processlist_get_process_pixels(process_list,
+ if(processlist_get_process_pixels(process_list,
+ pid_in,
+ process->last_cpu,
+ &birth,
+ tfc->t_context->index,
+ &y,
+ &height,
+ &hashed_process_data) == 1)
+ {
+ g_assert(pid_in == 0 || pid_in != process->ppid);
+ /* Process not present */
+ processlist_add(process_list,
+ pid_in,
+ process->last_cpu,
+ process->ppid,
+ &birth,
+ tfc->t_context->index,
+ name,
+ &pl_height,
+ &hashed_process_data);
+ processlist_get_process_pixels(process_list,
pid_in,
process->last_cpu,
&birth,
tfc->t_context->index,
&y,
&height,
- &hashed_process_data) == 1)
- {
- g_assert(pid_in == 0 || pid_in != process->ppid);
- /* Process not present */
- processlist_add(process_list,
- pid_in,
- process->last_cpu,
- process->ppid,
- &birth,
- tfc->t_context->index,
- name,
- &pl_height,
- &hashed_process_data);
- processlist_get_process_pixels(process_list,
- pid_in,
- process->last_cpu,
- &birth,
- tfc->t_context->index,
- &y,
- &height,
- &hashed_process_data);
- drawing_insert_square( drawing, y, height);
- }
+ &hashed_process_data);
+ drawing_insert_square( drawing, y, height);
+ }
+
+ /* Now, the process is in the state hash and our own process hash.
+ * We definitely can draw the items related to the ending state.
+ */
- /* Now, the process is in the state hash and our own process hash.
- * We definitely can draw the items related to the ending state.
- */
-
- /* Check if the x position is unset. In can have been left unset by
- * a draw closure from a after chunk hook. This should never happen,
- * because it must be set by before chunk hook to the damage_begin
- * value.
- */
- g_assert(hashed_process_data->x != -1);
+ /* Check if the x position is unset. In can have been left unset by
+ * a draw closure from a after chunk hook. This should never happen,
+ * because it must be set by before chunk hook to the damage_begin
+ * value.
+ */
+ g_assert(hashed_process_data->x.middle != -1);
+ {
+ guint x;
+
+ convert_time_to_pixels(
+ time_window.start_time,
+ end_time,
+ evtime,
+ width,
+ &x);
+
+
+ /* Jump over draw if we are at the same x position */
+ if(x == hashed_process_data->x.middle &&
+ hashed_process_data->x.middle_used)
{
- guint x;
+ if(hashed_process_data->x.middle_marked == FALSE) {
+ /* Draw collision indicator */
+ gdk_gc_set_foreground(drawing->gc, &drawing_colors[COL_WHITE]);
+ gdk_draw_point(drawing->pixmap,
+ drawing->gc,
+ x,
+ y+1);
+ }
+ /* jump */
+ } else {
DrawContext draw_context;
- convert_time_to_pixels(
- time_window.start_time,
- end_time,
- evtime,
- width,
- &x);
-
/* Now create the drawing context that will be used to draw
* items related to the last state. */
draw_context.drawable = drawing->pixmap;
draw_context.gc = drawing->gc;
draw_context.pango_layout = drawing->pango_layout;
- draw_context.drawinfo.start.x = hashed_process_data->x;
+ draw_context.drawinfo.start.x = hashed_process_data->x.middle;
draw_context.drawinfo.end.x = x;
- draw_context.drawinfo.y.over = y;
- draw_context.drawinfo.y.middle = y+(height/4);
- draw_context.drawinfo.y.under = y+(height/2)+2;
+ draw_context.drawinfo.y.over = y+1;
+ draw_context.drawinfo.y.middle = y+(height/2);
+ draw_context.drawinfo.y.under = y+height;
draw_context.drawinfo.start.offset.over = 0;
draw_context.drawinfo.start.offset.middle = 0;
{
/* Draw the line */
- PropertiesLine prop_line = prepare_status_line(process);
+ PropertiesLine prop_line = prepare_s_e_line(process);
draw_line((void*)&prop_line, (void*)&draw_context);
}
/* become the last x position */
- hashed_process_data->x = x;
+ hashed_process_data->x.middle = x;
+ hashed_process_data->x.middle_used = TRUE;
+ hashed_process_data->x.middle_marked = FALSE;
}
}
}
- } else if(strcmp(
- ltt_eventtype_name(ltt_event_eventtype(e)),"process") == 0) {
- /* We are in a fork or exit event */
-
-
}
-
-
return 0;
guint width = control_flow_data->drawing->width;
- if(strcmp(ltt_eventtype_name(ltt_event_eventtype(e)),"schedchange") == 0) {
+ /* Add process to process list (if not present) */
+ LttvProcessState *process_out, *process_in;
+ LttTime birth;
+ guint y_in = 0, y_out = 0, height = 0, pl_height = 0;
+ HashedProcessData *hashed_process_data_in = NULL;
- g_debug("schedchange!");
-
- {
- /* Add process to process list (if not present) */
- LttvProcessState *process_out, *process_in;
- LttTime birth;
- guint y_in = 0, y_out = 0, height = 0, pl_height = 0;
- HashedProcessData *hashed_process_data_in = NULL;
-
- ProcessList *process_list =
- guicontrolflow_get_process_list(control_flow_data);
-
- guint pid_in;
- {
- guint pid_out;
- LttField *f = ltt_event_field(e);
- LttField *element;
- element = ltt_field_member(f,0);
- pid_out = ltt_event_get_long_unsigned(e,element);
- element = ltt_field_member(f,1);
- pid_in = ltt_event_get_long_unsigned(e,element);
- g_debug("out : %u in : %u", pid_out, pid_in);
- }
+ ProcessList *process_list =
+ guicontrolflow_get_process_list(control_flow_data);
+
+ guint pid_in;
+ {
+ guint pid_out;
+ LttField *f = ltt_event_field(e);
+ LttField *element;
+ element = ltt_field_member(f,0);
+ pid_out = ltt_event_get_long_unsigned(e,element);
+ element = ltt_field_member(f,1);
+ pid_in = ltt_event_get_long_unsigned(e,element);
+ g_debug("out : %u in : %u", pid_out, pid_in);
+ }
- /* Find process pid_in in the list... */
- process_in = lttv_state_find_process(tfs, pid_in);
- /* It should exist, because we are after the state update. */
- g_assert(process_in != NULL);
+ /* Find process pid_in in the list... */
+ process_in = lttv_state_find_process(tfs, pid_in);
+ /* It should exist, because we are after the state update. */
+ g_assert(process_in != NULL);
- birth = process_in->creation_time;
- const gchar *name = g_quark_to_string(process_in->name);
+ birth = process_in->creation_time;
+ const gchar *name = g_quark_to_string(process_in->name);
- if(processlist_get_process_pixels(process_list,
- pid_in,
- process_in->last_cpu,
- &birth,
- tfc->t_context->index,
- &y_in,
- &height,
- &hashed_process_data_in) == 1)
- {
- g_assert(pid_in == 0 || pid_in != process_in->ppid);
- /* Process not present */
- processlist_add(process_list,
+ if(processlist_get_process_pixels(process_list,
+ pid_in,
+ process_in->last_cpu,
+ &birth,
+ tfc->t_context->index,
+ &y_in,
+ &height,
+ &hashed_process_data_in) == 1)
+ {
+ g_assert(pid_in == 0 || pid_in != process_in->ppid);
+ /* Process not present */
+ processlist_add(process_list,
+ pid_in,
+ process_in->last_cpu,
+ process_in->ppid,
+ &birth,
+ tfc->t_context->index,
+ name,
+ &pl_height,
+ &hashed_process_data_in);
+ processlist_get_process_pixels(process_list,
pid_in,
process_in->last_cpu,
- process_in->ppid,
&birth,
tfc->t_context->index,
- name,
- &pl_height,
+ &y_in,
+ &height,
&hashed_process_data_in);
- processlist_get_process_pixels(process_list,
- pid_in,
- process_in->last_cpu,
- &birth,
- tfc->t_context->index,
- &y_in,
- &height,
- &hashed_process_data_in);
- drawing_insert_square( control_flow_data->drawing, y_in, height);
- }
+ drawing_insert_square( control_flow_data->drawing, y_in, height);
+ }
- convert_time_to_pixels(
- time_window.start_time,
- end_time,
- evtime,
- width,
- &hashed_process_data_in->x);
- }
+ guint new_x;
+
+ convert_time_to_pixels(
+ time_window.start_time,
+ end_time,
+ evtime,
+ width,
+ &new_x);
+
+ if(hashed_process_data_in->x.middle != new_x) {
+ hashed_process_data_in->x.middle = new_x;
+ hashed_process_data_in->x.middle_used = FALSE;
+ hashed_process_data_in->x.middle_marked = FALSE;
}
+
return 0;
+
+
#if 0
EventsRequest *events_request = (EventsRequest*)hook_data;
ControlFlowData *control_flow_data = events_request->viewer_data;
#endif //0
}
-/* after_fork_hook
- *
- * Create the processlist entry for the child process. Put the last
- * position in x at the current time value.
- *
- * @param hook_data ControlFlowData structure of the viewer.
- * @param call_data Event context.
- *
- * This function adds items to be drawn in a queue for each process.
- *
- */
-int after_fork_hook(void *hook_data, void *call_data)
+#if 0
+static __inline PropertiesLine prepare_execmode_line(LttvProcessState *process)
{
- EventsRequest *events_request = (EventsRequest*)hook_data;
- ControlFlowData *control_flow_data = events_request->viewer_data;
-
- LttvTracefileContext *tfc = (LttvTracefileContext *)call_data;
-
- LttvTracefileState *tfs = (LttvTracefileState *)call_data;
- LttvTraceState *ts =(LttvTraceState *)LTTV_TRACEFILE_CONTEXT(tfs)->t_context;
-
- LttEvent *e;
- e = tfc->e;
-
- LttTime evtime = ltt_event_time(e);
- TimeWindow time_window =
+ PropertiesLine prop_line;
+ prop_line.line_width = 1;
+ prop_line.style = GDK_LINE_SOLID;
+ prop_line.y = OVER;
+ //GdkColormap *colormap = gdk_colormap_get_system();
+
+ /* color of line : execution mode of the process */
+ if(process->state->t == LTTV_STATE_USER_MODE)
+ prop_line.color = drawing_colors[COL_USER_MODE];
+ else if(process->state->t == LTTV_STATE_SYSCALL)
+ prop_line.color = drawing_colors[COL_SYSCALL];
+ else if(process->state->t == LTTV_STATE_TRAP)
+ prop_line.color = drawing_colors[COL_TRAP];
+ else if(process->state->t == LTTV_STATE_IRQ)
+ prop_line.color = drawing_colors[COL_IRQ];
+ else if(process->state->t == LTTV_STATE_MODE_UNKNOWN)
+ prop_line.color = drawing_colors[COL_MODE_UNKNOWN];
+ else
+ prop_line.color = drawing_colors[COL_WHITE];
+
+ //gdk_colormap_alloc_color(colormap,
+ // prop_line.color,
+ // FALSE,
+ // TRUE);
+
+ return prop_line;
+
+}
+#endif //0
+
+
+/* before_execmode_hook
+ *
+ * This function basically draw lines and icons. Two types of lines are drawn :
+ * one small (3 pixels?) representing the state of the process and the second
+ * type is thicker (10 pixels?) representing on which CPU a process is running
+ * (and this only in running state).
+ *
+ * Extremums of the lines :
+ * x_min : time of the last event context for this process kept in memory.
+ * x_max : time of the current event.
+ * y : middle of the process in the process list. The process is found in the
+ * list, therefore is it's position in pixels.
+ *
+ * The choice of lines'color is defined by the context of the last event for this
+ * process.
+ */
+
+
+int before_execmode_hook(void *hook_data, void *call_data)
+{
+ EventsRequest *events_request = (EventsRequest*)hook_data;
+ ControlFlowData *control_flow_data = events_request->viewer_data;
+ Drawing_t *drawing = control_flow_data->drawing;
+
+ LttvTracefileContext *tfc = (LttvTracefileContext *)call_data;
+
+ LttvTracefileState *tfs = (LttvTracefileState *)call_data;
+ LttvTraceState *ts =(LttvTraceState *)LTTV_TRACEFILE_CONTEXT(tfs)->t_context;
+
+ LttEvent *e;
+ e = tfc->e;
+
+ LttTime evtime = ltt_event_time(e);
+ TimeWindow time_window =
+ lttvwindow_get_time_window(control_flow_data->tab);
+
+ LttTime end_time = ltt_time_add(time_window.start_time,
+ time_window.time_width);
+
+ if(ltt_time_compare(evtime, time_window.start_time) == -1
+ || ltt_time_compare(evtime, end_time) == 1)
+ return;
+
+ guint width = drawing->width;
+
+ /* we are in a execmode, before the state update. We must draw the
+ * items corresponding to the state before it changes : now is the right
+ * time to do it.
+ */
+ /* For the pid */
+ LttvProcessState *process = tfs->process;
+ g_assert(process != NULL);
+
+ guint pid = process->pid;
+
+ /* Well, the process_out existed : we must get it in the process hash
+ * or add it, and draw its items.
+ */
+ /* Add process to process list (if not present) */
+ guint y = 0, height = 0, pl_height = 0;
+ HashedProcessData *hashed_process_data = NULL;
+ ProcessList *process_list =
+ guicontrolflow_get_process_list(control_flow_data);
+ LttTime birth = process->creation_time;
+ const gchar *name = g_quark_to_string(process->name);
+
+ if(processlist_get_process_pixels(process_list,
+ pid,
+ process->last_cpu,
+ &birth,
+ tfc->t_context->index,
+ &y,
+ &height,
+ &hashed_process_data) == 1)
+ {
+ g_assert(pid == 0 || pid != process->ppid);
+ /* Process not present */
+ processlist_add(process_list,
+ pid,
+ process->last_cpu,
+ process->ppid,
+ &birth,
+ tfc->t_context->index,
+ name,
+ &pl_height,
+ &hashed_process_data);
+ processlist_get_process_pixels(process_list,
+ pid,
+ process->last_cpu,
+ &birth,
+ tfc->t_context->index,
+ &y,
+ &height,
+ &hashed_process_data);
+ drawing_insert_square( drawing, y, height);
+ }
+
+ /* Now, the process is in the state hash and our own process hash.
+ * We definitely can draw the items related to the ending state.
+ */
+
+ /* Check if the x position is unset. In can have been left unset by
+ * a draw closure from a after chunk hook. This should never happen,
+ * because it must be set by before chunk hook to the damage_begin
+ * value.
+ */
+ g_assert(hashed_process_data->x.over != -1);
+ {
+ guint x;
+
+ convert_time_to_pixels(
+ time_window.start_time,
+ end_time,
+ evtime,
+ width,
+ &x);
+
+
+ /* Jump over draw if we are at the same x position */
+ if(x == hashed_process_data->x.middle &&
+ hashed_process_data->x.middle_used)
+ {
+ if(hashed_process_data->x.middle_marked == FALSE) {
+ /* Draw collision indicator */
+ gdk_gc_set_foreground(drawing->gc, &drawing_colors[COL_WHITE]);
+ gdk_draw_point(drawing->pixmap,
+ drawing->gc,
+ x,
+ y+1);
+ }
+ /* jump */
+ } else {
+
+ DrawContext draw_context;
+ /* Now create the drawing context that will be used to draw
+ * items related to the last state. */
+ draw_context.drawable = drawing->pixmap;
+ draw_context.gc = drawing->gc;
+ draw_context.pango_layout = drawing->pango_layout;
+ draw_context.drawinfo.start.x = hashed_process_data->x.middle;
+ draw_context.drawinfo.end.x = x;
+
+ draw_context.drawinfo.y.over = y+1;
+ draw_context.drawinfo.y.middle = y+(height/2);
+ draw_context.drawinfo.y.under = y+height;
+
+ draw_context.drawinfo.start.offset.over = 0;
+ draw_context.drawinfo.start.offset.middle = 0;
+ draw_context.drawinfo.start.offset.under = 0;
+ draw_context.drawinfo.end.offset.over = 0;
+ draw_context.drawinfo.end.offset.middle = 0;
+ draw_context.drawinfo.end.offset.under = 0;
+
+ {
+ /* Draw the line */
+ PropertiesLine prop_line = prepare_s_e_line(process);
+ draw_line((void*)&prop_line, (void*)&draw_context);
+
+ }
+ /* become the last x position */
+ hashed_process_data->x.middle = x;
+ hashed_process_data->x.middle_used = TRUE;
+ hashed_process_data->x.middle_marked = FALSE;
+ }
+ }
+
+ return 0;
+}
+
+/* after_execmode_hook
+ *
+ * The draw after hook is called by the reading API to have a
+ * particular event drawn on the screen.
+ * @param hook_data ControlFlowData structure of the viewer.
+ * @param call_data Event context.
+ *
+ * This function adds items to be drawn in a queue for each process.
+ *
+ */
+int after_execmode_hook(void *hook_data, void *call_data)
+{
+ EventsRequest *events_request = (EventsRequest*)hook_data;
+ ControlFlowData *control_flow_data = events_request->viewer_data;
+
+ LttvTracefileContext *tfc = (LttvTracefileContext *)call_data;
+
+ LttvTracefileState *tfs = (LttvTracefileState *)call_data;
+ LttvTraceState *ts =(LttvTraceState *)LTTV_TRACEFILE_CONTEXT(tfs)->t_context;
+
+ LttEvent *e;
+ e = tfc->e;
+
+ LttTime evtime = ltt_event_time(e);
+ TimeWindow time_window =
+ lttvwindow_get_time_window(control_flow_data->tab);
+
+ LttTime end_time = ltt_time_add(time_window.start_time,
+ time_window.time_width);
+
+ if(ltt_time_compare(evtime, time_window.start_time) == -1
+ || ltt_time_compare(evtime, end_time) == 1)
+ return;
+
+ guint width = control_flow_data->drawing->width;
+
+ /* Add process to process list (if not present) */
+ LttvProcessState *process;
+ LttTime birth;
+ guint y = 0, height = 0, pl_height = 0;
+ HashedProcessData *hashed_process_data = NULL;
+
+ ProcessList *process_list =
+ guicontrolflow_get_process_list(control_flow_data);
+
+
+ /* Find process pid_in in the list... */
+ process = tfs->process;
+ /* It should exist, because we are after the state update. */
+ g_assert(process != NULL);
+
+ guint pid = process->pid;
+
+ birth = process->creation_time;
+ const gchar *name = g_quark_to_string(process->name);
+
+ if(processlist_get_process_pixels(process_list,
+ pid,
+ process->last_cpu,
+ &birth,
+ tfc->t_context->index,
+ &y,
+ &height,
+ &hashed_process_data) == 1)
+ {
+ g_assert(pid == 0 || pid != process->ppid);
+ /* Process not present */
+ processlist_add(process_list,
+ pid,
+ process->last_cpu,
+ process->ppid,
+ &birth,
+ tfc->t_context->index,
+ name,
+ &pl_height,
+ &hashed_process_data);
+ processlist_get_process_pixels(process_list,
+ pid,
+ process->last_cpu,
+ &birth,
+ tfc->t_context->index,
+ &y,
+ &height,
+ &hashed_process_data);
+ drawing_insert_square( control_flow_data->drawing, y, height);
+ }
+
+ guint new_x;
+
+ convert_time_to_pixels(
+ time_window.start_time,
+ end_time,
+ evtime,
+ width,
+ &new_x);
+
+ if(hashed_process_data->x.middle != new_x) {
+ hashed_process_data->x.middle = new_x;
+ hashed_process_data->x.middle_used = FALSE;
+ hashed_process_data->x.middle_marked = FALSE;
+ }
+
+ return 0;
+}
+
+
+
+/* before_process_hook
+ *
+ * Draw lines for process event.
+ *
+ * @param hook_data ControlFlowData structure of the viewer.
+ * @param call_data Event context.
+ *
+ * This function adds items to be drawn in a queue for each process.
+ *
+ */
+int before_process_hook(void *hook_data, void *call_data)
+{
+ EventsRequest *events_request = (EventsRequest*)hook_data;
+ ControlFlowData *control_flow_data = events_request->viewer_data;
+ Drawing_t *drawing = control_flow_data->drawing;
+
+ LttvTracefileContext *tfc = (LttvTracefileContext *)call_data;
+
+ LttvTracefileState *tfs = (LttvTracefileState *)call_data;
+ LttvTraceState *ts =(LttvTraceState *)LTTV_TRACEFILE_CONTEXT(tfs)->t_context;
+
+ LttEvent *e;
+ e = tfc->e;
+
+ LttTime evtime = ltt_event_time(e);
+ TimeWindow time_window =
lttvwindow_get_time_window(control_flow_data->tab);
LttTime end_time = ltt_time_add(time_window.start_time,
guint width = control_flow_data->drawing->width;
- if(strcmp(ltt_eventtype_name(ltt_event_eventtype(e)),"process") == 0) {
+ guint sub_id;
+ {
+ LttField *f = ltt_event_field(e);
+ LttField *element;
+ element = ltt_field_member(f,0);
+ sub_id = ltt_event_get_long_unsigned(e,element);
+ }
+
+ if(sub_id == 3) { /* exit */
+
+ /* Add process to process list (if not present) */
+ LttvProcessState *process = tfs->process;
+ guint pid = process->pid;
+ LttTime birth;
+ guint y = 0, height = 0, pl_height = 0;
+ HashedProcessData *hashed_process_data = NULL;
- guint sub_id;
- guint child_pid;
+ ProcessList *process_list =
+ guicontrolflow_get_process_list(control_flow_data);
+
+ g_assert(process != NULL);
+
+ birth = process->creation_time;
+ const gchar *name = g_quark_to_string(process->name);
+
+ if(processlist_get_process_pixels(process_list,
+ pid,
+ process->last_cpu,
+ &birth,
+ tfc->t_context->index,
+ &y,
+ &height,
+ &hashed_process_data) == 1)
{
- LttField *f = ltt_event_field(e);
- LttField *element;
- element = ltt_field_member(f,0);
- sub_id = ltt_event_get_long_unsigned(e,element);
- element = ltt_field_member(f,1);
- child_pid = ltt_event_get_long_unsigned(e,element);
+ g_assert(pid == 0 || pid != process->ppid);
+ /* Process not present */
+ processlist_add(process_list,
+ pid,
+ process->last_cpu,
+ process->ppid,
+ &birth,
+ tfc->t_context->index,
+ name,
+ &pl_height,
+ &hashed_process_data);
+ processlist_get_process_pixels(process_list,
+ pid,
+ process->last_cpu,
+ &birth,
+ tfc->t_context->index,
+ &y,
+ &height,
+ &hashed_process_data);
+ drawing_insert_square( control_flow_data->drawing, y, height);
}
- if(sub_id == 2) { /* fork */
+ /* Now, the process is in the state hash and our own process hash.
+ * We definitely can draw the items related to the ending state.
+ */
+
+ /* Check if the x position is unset. In can have been left unset by
+ * a draw closure from a after chunk hook. This should never happen,
+ * because it must be set by before chunk hook to the damage_begin
+ * value.
+ */
+ g_assert(hashed_process_data->x.over != -1);
+ {
+ guint x;
+
+ convert_time_to_pixels(
+ time_window.start_time,
+ end_time,
+ evtime,
+ width,
+ &x);
- /* Add process to process list (if not present) */
- LttvProcessState *process_child;
- LttTime birth;
- guint y_child = 0, height = 0, pl_height = 0;
- HashedProcessData *hashed_process_data_child = NULL;
- ProcessList *process_list =
- guicontrolflow_get_process_list(control_flow_data);
-
+ /* Jump over draw if we are at the same x position */
+ if(x == hashed_process_data->x.middle &&
+ hashed_process_data->x.middle_used)
+ {
+ if(hashed_process_data->x.middle_marked == FALSE) {
+ /* Draw collision indicator */
+ gdk_gc_set_foreground(drawing->gc, &drawing_colors[COL_WHITE]);
+ gdk_draw_point(drawing->pixmap,
+ drawing->gc,
+ x,
+ y+1);
+ }
+ /* jump */
+ } else {
+ DrawContext draw_context;
- /* Find child in the list... */
- process_child = lttv_state_find_process(tfs, child_pid);
- /* It should exist, because we are after the state update. */
- g_assert(process_child != NULL);
+ /* Now create the drawing context that will be used to draw
+ * items related to the last state. */
+ draw_context.drawable = drawing->pixmap;
+ draw_context.gc = drawing->gc;
+ draw_context.pango_layout = drawing->pango_layout;
+ draw_context.drawinfo.start.x = hashed_process_data->x.middle;
+ draw_context.drawinfo.end.x = x;
- birth = process_child->creation_time;
- const gchar *name = g_quark_to_string(process_child->name);
+ draw_context.drawinfo.y.over = y+1;
+ draw_context.drawinfo.y.middle = y+(height/2);
+ draw_context.drawinfo.y.under = y+height;
- if(processlist_get_process_pixels(process_list,
+ draw_context.drawinfo.start.offset.over = 0;
+ draw_context.drawinfo.start.offset.middle = 0;
+ draw_context.drawinfo.start.offset.under = 0;
+ draw_context.drawinfo.end.offset.over = 0;
+ draw_context.drawinfo.end.offset.middle = 0;
+ draw_context.drawinfo.end.offset.under = 0;
+
+ {
+ /* Draw the line */
+ PropertiesLine prop_line = prepare_s_e_line(process);
+ draw_line((void*)&prop_line, (void*)&draw_context);
+
+ }
+ /* become the last x position */
+ hashed_process_data->x.middle = x;
+ hashed_process_data->x.middle_used = TRUE;
+ hashed_process_data->x.middle_marked = FALSE;
+ }
+ }
+
+ }
+ return 0;
+
+}
+
+
+
+
+
+
+/* after_process_hook
+ *
+ * Create the processlist entry for the child process. Put the last
+ * position in x at the current time value.
+ *
+ * @param hook_data ControlFlowData structure of the viewer.
+ * @param call_data Event context.
+ *
+ * This function adds items to be drawn in a queue for each process.
+ *
+ */
+int after_process_hook(void *hook_data, void *call_data)
+{
+ EventsRequest *events_request = (EventsRequest*)hook_data;
+ ControlFlowData *control_flow_data = events_request->viewer_data;
+
+ LttvTracefileContext *tfc = (LttvTracefileContext *)call_data;
+
+ LttvTracefileState *tfs = (LttvTracefileState *)call_data;
+ LttvTraceState *ts =(LttvTraceState *)LTTV_TRACEFILE_CONTEXT(tfs)->t_context;
+
+ LttEvent *e;
+ e = tfc->e;
+
+ LttTime evtime = ltt_event_time(e);
+ TimeWindow time_window =
+ lttvwindow_get_time_window(control_flow_data->tab);
+
+ LttTime end_time = ltt_time_add(time_window.start_time,
+ time_window.time_width);
+
+ if(ltt_time_compare(evtime, time_window.start_time) == -1
+ || ltt_time_compare(evtime, end_time) == 1)
+ return;
+
+ guint width = control_flow_data->drawing->width;
+
+ guint sub_id;
+ guint param1;
+ {
+ LttField *f = ltt_event_field(e);
+ LttField *element;
+ element = ltt_field_member(f,0);
+ sub_id = ltt_event_get_long_unsigned(e,element);
+ element = ltt_field_member(f,1);
+ param1 = ltt_event_get_long_unsigned(e,element);
+ }
+
+ if(sub_id == 2) { /* fork */
+
+ guint child_pid = param1;
+ /* Add process to process list (if not present) */
+ LttvProcessState *process_child;
+ LttTime birth;
+ guint y_child = 0, height = 0, pl_height = 0;
+ HashedProcessData *hashed_process_data_child = NULL;
+
+ ProcessList *process_list =
+ guicontrolflow_get_process_list(control_flow_data);
+
+
+ /* Find child in the list... */
+ process_child = lttv_state_find_process(tfs, child_pid);
+ /* It should exist, because we are after the state update. */
+ g_assert(process_child != NULL);
+
+ birth = process_child->creation_time;
+ const gchar *name = g_quark_to_string(process_child->name);
+
+ if(processlist_get_process_pixels(process_list,
+ child_pid,
+ process_child->last_cpu,
+ &birth,
+ tfc->t_context->index,
+ &y_child,
+ &height,
+ &hashed_process_data_child) == 1)
+ {
+ g_assert(child_pid == 0 || child_pid != process_child->ppid);
+ /* Process not present */
+ processlist_add(process_list,
+ child_pid,
+ process_child->last_cpu,
+ process_child->ppid,
+ &birth,
+ tfc->t_context->index,
+ name,
+ &pl_height,
+ &hashed_process_data_child);
+ processlist_get_process_pixels(process_list,
child_pid,
process_child->last_cpu,
&birth,
tfc->t_context->index,
&y_child,
&height,
- &hashed_process_data_child) == 1)
- {
- g_assert(child_pid == 0 || child_pid != process_child->ppid);
- /* Process not present */
- processlist_add(process_list,
- child_pid,
- process_child->last_cpu,
- process_child->ppid,
+ &hashed_process_data_child);
+ drawing_insert_square( control_flow_data->drawing, y_child, height);
+ }
+
+ guint new_x;
+ convert_time_to_pixels(
+ time_window.start_time,
+ end_time,
+ evtime,
+ width,
+ &new_x);
+
+ if(hashed_process_data_child->x.over != new_x) {
+ hashed_process_data_child->x.over = new_x;
+ hashed_process_data_child->x.over_used = FALSE;
+ hashed_process_data_child->x.over_marked = FALSE;
+ }
+ if(hashed_process_data_child->x.middle != new_x) {
+ hashed_process_data_child->x.middle = new_x;
+ hashed_process_data_child->x.middle_used = FALSE;
+ hashed_process_data_child->x.middle_marked = FALSE;
+ }
+ if(hashed_process_data_child->x.under != new_x) {
+ hashed_process_data_child->x.under = new_x;
+ hashed_process_data_child->x.under_used = FALSE;
+ hashed_process_data_child->x.under_marked = FALSE;
+ }
+
+ } else if(sub_id == 3) { /* exit */
+
+ /* Add process to process list (if not present) */
+ LttvProcessState *process = tfs->process;
+ guint pid = process->pid;
+ LttTime birth;
+ guint y = 0, height = 0, pl_height = 0;
+ HashedProcessData *hashed_process_data = NULL;
+
+ ProcessList *process_list =
+ guicontrolflow_get_process_list(control_flow_data);
+
+
+ /* It should exist, because we are after the state update. */
+ g_assert(process != NULL);
+
+ birth = process->creation_time;
+ const gchar *name = g_quark_to_string(process->name);
+
+ if(processlist_get_process_pixels(process_list,
+ pid,
+ process->last_cpu,
&birth,
tfc->t_context->index,
- name,
- &pl_height,
- &hashed_process_data_child);
- processlist_get_process_pixels(process_list,
- child_pid,
- process_child->last_cpu,
- &birth,
- tfc->t_context->index,
- &y_child,
- &height,
- &hashed_process_data_child);
- drawing_insert_square( control_flow_data->drawing, y_child, height);
- }
+ &y,
+ &height,
+ &hashed_process_data) == 1)
+ {
+ g_assert(pid == 0 || pid != process->ppid);
+ /* Process not present */
+ processlist_add(process_list,
+ pid,
+ process->last_cpu,
+ process->ppid,
+ &birth,
+ tfc->t_context->index,
+ name,
+ &pl_height,
+ &hashed_process_data);
+ processlist_get_process_pixels(process_list,
+ pid,
+ process->last_cpu,
+ &birth,
+ tfc->t_context->index,
+ &y,
+ &height,
+ &hashed_process_data);
+ drawing_insert_square( control_flow_data->drawing, y, height);
+ }
- convert_time_to_pixels(
- time_window.start_time,
- end_time,
- evtime,
- width,
- &hashed_process_data_child->x);
+ guint new_x;
+ convert_time_to_pixels(
+ time_window.start_time,
+ end_time,
+ evtime,
+ width,
+ &new_x);
+ if(hashed_process_data->x.middle != new_x) {
+ hashed_process_data->x.middle = new_x;
+ hashed_process_data->x.middle_used = FALSE;
+ hashed_process_data->x.middle_marked = FALSE;
}
+
+
}
return 0;
drawing->damage_begin = 0;
drawing->damage_end = drawing->width;
+ /* fun feature, to be separated someday... */
+ drawing_clear(control_flow_data->drawing);
+ processlist_clear(control_flow_data->process_list);
// Clear the image
gdk_draw_rectangle (drawing->pixmap,
0,0,
drawing->width,
drawing->height);
-
return FALSE;
}
LttTime time_begin = time_window.start_time;
LttTime width = time_window.time_width;
- LttTime half_width = ltt_time_div(width,2.0);
+ LttTime half_width;
+ {
+ guint64 time_ll = ltt_time_to_uint64(width);
+ time_ll = time_ll >> 1; /* divide by two */
+ half_width = ltt_time_from_uint64(time_ll);
+ }
LttTime time_end = ltt_time_add(time_begin, width);
LttvTracesetContext * tsc =
* because it must be set by before chunk hook to the damage_begin
* value.
*/
- g_assert(hashed_process_data->x != -1);
+ g_assert(hashed_process_data->x.over != -1);
{
guint x;
- DrawContext draw_context;
convert_time_to_pixels(
time_window.start_time,
width,
&x);
+ DrawContext draw_context;
+
/* Now create the drawing context that will be used to draw
* items related to the last state. */
draw_context.drawable = drawing->pixmap;
draw_context.gc = drawing->gc;
draw_context.pango_layout = drawing->pango_layout;
- draw_context.drawinfo.start.x = hashed_process_data->x;
draw_context.drawinfo.end.x = x;
- draw_context.drawinfo.y.over = y;
- draw_context.drawinfo.y.middle = y+(height/4);
- draw_context.drawinfo.y.under = y+(height/2)+2;
+ draw_context.drawinfo.y.over = y+1;
+ draw_context.drawinfo.y.middle = y+(height/2);
+ draw_context.drawinfo.y.under = y+height;
draw_context.drawinfo.start.offset.over = 0;
draw_context.drawinfo.start.offset.middle = 0;
draw_context.drawinfo.end.offset.over = 0;
draw_context.drawinfo.end.offset.middle = 0;
draw_context.drawinfo.end.offset.under = 0;
-
+#if 0
+ /* Jump over draw if we are at the same x position */
+ if(x == hashed_process_data->x.over)
{
+ /* jump */
+ } else {
+ draw_context.drawinfo.start.x = hashed_process_data->x.over;
/* Draw the line */
- PropertiesLine prop_line = prepare_status_line(process);
+ PropertiesLine prop_line = prepare_execmode_line(process);
draw_line((void*)&prop_line, (void*)&draw_context);
+ hashed_process_data->x.over = x;
}
+#endif //0
- /* special case LTTV_STATE_WAIT : CPU is unknown. */
-
- /* become the last x position */
- hashed_process_data->x = x;
+ if(x == hashed_process_data->x.middle &&
+ hashed_process_data->x.middle_used) {
+ if(hashed_process_data->x.middle_marked == FALSE) {
+ /* Draw collision indicator */
+ gdk_gc_set_foreground(drawing->gc, &drawing_colors[COL_WHITE]);
+ gdk_draw_point(drawing->pixmap,
+ drawing->gc,
+ x,
+ draw_context.drawinfo.y.over);
+ }
+ /* Jump */
+ } else {
+ draw_context.drawinfo.start.x = hashed_process_data->x.middle;
+ /* Draw the line */
+ PropertiesLine prop_line = prepare_s_e_line(process);
+ draw_line((void*)&prop_line, (void*)&draw_context);
+
+ /* become the last x position */
+ if(x != hashed_process_data->x.middle) {
+ hashed_process_data->x.middle = x;
+ /* but don't use the pixel */
+ hashed_process_data->x.middle_used = FALSE;
+ }
+ }
}
}
}
projects / lttv.git / blobdiff