LttTime birth;
guint y = 0, height = 0, pl_height = 0;
- ProcessList *process_list =
- guicontrolflow_get_process_list(control_flow_data);
+ ProcessList *process_list = control_flow_data->process_list;
pid = process->pid;
birth = process->creation_time;
}
+/* 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));
-static __inline PropertiesLine prepare_status_line(LttvProcessState *process)
+ 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.line_width = 2;
return prop_line;
}
-
+#endif //0
/* before_schedchange_hook
LttvTracefileContext *tfc = (LttvTracefileContext *)call_data;
LttvTracefileState *tfs = (LttvTracefileState *)call_data;
- LttvTraceState *ts =(LttvTraceState *)LTTV_TRACEFILE_CONTEXT(tfs)->t_context;
+ LttvTraceState *ts =(LttvTraceState *)((LttvTracefileContext*)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 schedchange, before the state update. We must draw the
* 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);
+ /* unknown state, bad current pid */
+ if(tfs->process->pid != pid_out)
+ process = lttv_state_find_process(tfs, pid_out);
+ else
+ process = tfs->process;
if(process != NULL) {
/* Well, the process_out existed : we must get it in the process hash
/* 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);
+ ProcessList *process_list = control_flow_data->process_list;
LttTime birth = process->creation_time;
- const gchar *name = g_quark_to_string(process->name);
if(processlist_get_process_pixels(process_list,
pid_out,
- process->last_cpu,
+ process->last_cpu_index,
&birth,
tfc->t_context->index,
&y,
&hashed_process_data) == 1)
{
g_assert(pid_out == 0 || pid_out != process->ppid);
+ const gchar *name = g_quark_to_string(process->name);
/* Process not present */
+ ProcessInfo *process_info;
processlist_add(process_list,
pid_out,
- process->last_cpu,
+ process->last_cpu_index,
process->ppid,
&birth,
tfc->t_context->index,
name,
&pl_height,
+ &process_info,
&hashed_process_data);
- processlist_get_process_pixels(process_list,
- pid_out,
- process->last_cpu,
- &birth,
- tfc->t_context->index,
+ processlist_get_pixels_from_data(process_list,
+ hashed_process_data,
&y,
- &height,
- &hashed_process_data);
+ &height);
drawing_insert_square( drawing, y, height);
}
* value.
*/
g_assert(hashed_process_data->x.middle != -1);
+ if(ltt_time_compare(hashed_process_data->next_good_time,
+ evtime) > 0)
{
+ if(hashed_process_data->x.middle_marked == FALSE) {
+ TimeWindow time_window =
+ lttvwindow_get_time_window(control_flow_data->tab);
+#ifdef EXTRA_CHECK
+ if(ltt_time_compare(evtime, time_window.start_time) == -1
+ || ltt_time_compare(evtime, time_window.end_time) == 1)
+ return;
+#endif //EXTRA_CHECK
+
+ guint x;
+ convert_time_to_pixels(
+ time_window,
+ evtime,
+ width,
+ &x);
+
+ /* Draw collision indicator */
+ gdk_gc_set_foreground(drawing->gc, &drawing_colors[COL_WHITE]);
+ gdk_draw_point(drawing->pixmap,
+ drawing->gc,
+ x,
+ y+(height/2)-3);
+ hashed_process_data->x.middle_marked = TRUE;
+ }
+ } else {
+ TimeWindow time_window =
+ lttvwindow_get_time_window(control_flow_data->tab);
+#ifdef EXTRA_CHECK
+ if(ltt_time_compare(evtime, time_window.start_time) == -1
+ || ltt_time_compare(evtime, time_window.end_time) == 1)
+ return;
+#endif //EXTRA_CHECK
+
guint x;
convert_time_to_pixels(
- time_window.start_time,
- end_time,
+ time_window,
evtime,
width,
&x);
/* Jump over draw if we are at the same x position */
- if(x == hashed_process_data->x.middle)
+ 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+(height/2)-3);
+ hashed_process_data->x.middle_marked = TRUE;
+ }
/* jump */
} else {
DrawContext draw_context;
{
/* 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.middle = x;
+ hashed_process_data->x.middle_used = TRUE;
+ hashed_process_data->x.middle_marked = FALSE;
+
+ /* Calculate the next good time */
+ convert_pixels_to_time(width, x+1, time_window,
+ &hashed_process_data->next_good_time);
}
}
}
/* 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);
+ ProcessList *process_list = control_flow_data->process_list;
LttTime birth = process->creation_time;
- const gchar *name = g_quark_to_string(process->name);
if(processlist_get_process_pixels(process_list,
pid_in,
- process->last_cpu,
+ process->last_cpu_index,
&birth,
tfc->t_context->index,
&y,
&hashed_process_data) == 1)
{
g_assert(pid_in == 0 || pid_in != process->ppid);
+ const gchar *name = g_quark_to_string(process->name);
/* Process not present */
+ ProcessInfo *process_info;
processlist_add(process_list,
pid_in,
- process->last_cpu,
+ process->last_cpu_index,
process->ppid,
&birth,
tfc->t_context->index,
name,
&pl_height,
+ &process_info,
&hashed_process_data);
- processlist_get_process_pixels(process_list,
- pid_in,
- process->last_cpu,
- &birth,
- tfc->t_context->index,
+ processlist_get_pixels_from_data(process_list,
+ hashed_process_data,
&y,
- &height,
- &hashed_process_data);
+ &height);
drawing_insert_square( drawing, y, height);
}
+ //We could set the current process and hash here, but will be done
+ //by after schedchange hook
/* Now, the process is in the state hash and our own process hash.
* We definitely can draw the items related to the ending state.
* value.
*/
g_assert(hashed_process_data->x.middle != -1);
+
+ if(ltt_time_compare(hashed_process_data->next_good_time,
+ evtime) > 0)
{
+ if(hashed_process_data->x.middle_marked == FALSE) {
+ TimeWindow time_window =
+ lttvwindow_get_time_window(control_flow_data->tab);
+#ifdef EXTRA_CHECK
+ if(ltt_time_compare(evtime, time_window.start_time) == -1
+ || ltt_time_compare(evtime, time_window.end_time) == 1)
+ return;
+#endif //EXTRA_CHECK
+ guint x;
+ convert_time_to_pixels(
+ time_window,
+ evtime,
+ width,
+ &x);
+
+ /* Draw collision indicator */
+ gdk_gc_set_foreground(drawing->gc, &drawing_colors[COL_WHITE]);
+ gdk_draw_point(drawing->pixmap,
+ drawing->gc,
+ x,
+ y+(height/2)-3);
+ hashed_process_data->x.middle_marked = TRUE;
+ }
+ } else {
+ TimeWindow time_window =
+ lttvwindow_get_time_window(control_flow_data->tab);
+#ifdef EXTRA_CHECK
+ if(ltt_time_compare(evtime, time_window.start_time) == -1
+ || ltt_time_compare(evtime, time_window.end_time) == 1)
+ return;
+#endif //EXTRA_CHECK
guint x;
convert_time_to_pixels(
- time_window.start_time,
- end_time,
+ time_window,
evtime,
width,
&x);
/* Jump over draw if we are at the same x position */
- if(x == hashed_process_data->x.middle)
+ 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+(height/2)-3);
+ hashed_process_data->x.middle_marked = TRUE;
+ }
/* jump */
} else {
DrawContext draw_context;
{
/* 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.middle = x;
+ hashed_process_data->x.middle_used = TRUE;
+ hashed_process_data->x.middle_marked = FALSE;
+
+ /* Calculate the next good time */
+ convert_pixels_to_time(width, x+1, time_window,
+ &hashed_process_data->next_good_time);
}
}
}
TimeWindow time_window =
lttvwindow_get_time_window(tab);
- LttTime end_time = ltt_time_add(time_window.start_time,
- time_window.time_width);
+ LttTime time_window.end_time = time_window.time_window.end_time;
+
//if(time < time_beg || time > time_end) return;
if(ltt_time_compare(evtime, time_window.start_time) == -1
- || ltt_time_compare(evtime, end_time) == 1)
+ || ltt_time_compare(evtime, time_window.end_time) == 1)
return;
if(strcmp(ltt_eventtype_name(ltt_event_eventtype(e)),"schedchange") == 0)
LttTime birth;
guint y_in = 0, y_out = 0, height = 0, pl_height = 0;
- ProcessList *process_list =
- guicontrolflow_get_process_list(control_flow_data);
+ ProcessList *process_list = control_flow_data->process_list;
LttField *f = ltt_event_field(e);
LttTime time = ltt_event_time(e);
- LttTime window_end = ltt_time_add(time_window.time_width,
- time_window.start_time);
-
+ LttTime window_end = time_window.time_window.end_time;
convert_time_to_pixels(
- time_window.start_time,
- window_end,
+ time_window,
time,
width,
&x);
LttvTracefileContext *tfc = (LttvTracefileContext *)call_data;
LttvTracefileState *tfs = (LttvTracefileState *)call_data;
- LttvTraceState *ts =(LttvTraceState *)LTTV_TRACEFILE_CONTEXT(tfs)->t_context;
+ LttvTraceState *ts =(LttvTraceState *)((LttvTracefileContext*)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 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);
+ ProcessList *process_list = control_flow_data->process_list;
guint pid_in;
{
/* Find process pid_in in the list... */
- process_in = lttv_state_find_process(tfs, pid_in);
+ //process_in = lttv_state_find_process(tfs, pid_in);
+ process_in = tfs->process;
/* 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);
if(processlist_get_process_pixels(process_list,
pid_in,
- process_in->last_cpu,
+ process_in->last_cpu_index,
&birth,
tfc->t_context->index,
&y_in,
&hashed_process_data_in) == 1)
{
g_assert(pid_in == 0 || pid_in != process_in->ppid);
+ const gchar *name = g_quark_to_string(process_in->name);
+ ProcessInfo *process_info;
/* Process not present */
processlist_add(process_list,
pid_in,
- process_in->last_cpu,
+ process_in->last_cpu_index,
process_in->ppid,
&birth,
tfc->t_context->index,
name,
&pl_height,
+ &process_info,
&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);
+ processlist_get_pixels_from_data(process_list,
+ hashed_process_data_in,
+ &y_in,
+ &height);
drawing_insert_square( control_flow_data->drawing, y_in, height);
}
+ /* Set the current process */
+ process_list->current_hash_data[process_in->last_cpu_index] =
+ hashed_process_data_in;
- convert_time_to_pixels(
- time_window.start_time,
- end_time,
- evtime,
- width,
- &hashed_process_data_in->x.middle);
+ if(ltt_time_compare(hashed_process_data_in->next_good_time,
+ evtime) <= 0)
+ {
+ TimeWindow time_window =
+ lttvwindow_get_time_window(control_flow_data->tab);
+
+#ifdef EXTRA_CHECK
+ if(ltt_time_compare(evtime, time_window.start_time) == -1
+ || ltt_time_compare(evtime, time_window.end_time) == 1)
+ return;
+#endif //EXTRA_CHECK
+
+ guint new_x;
+
+ convert_time_to_pixels(
+ time_window,
+ 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;
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);
+ LttTime time_window.end_time = time_window.time_window.end_time;
+
//if(time < time_beg || time > time_end) return;
if(ltt_time_compare(evtime, time_window.start_time) == -1
- || ltt_time_compare(evtime, end_time) == 1)
+ || ltt_time_compare(evtime, time_window.end_time) == 1)
return;
LttTime birth;
guint y_in = 0, y_out = 0, height = 0, pl_height = 0;
- ProcessList *process_list =
- guicontrolflow_get_process_list(control_flow_data);
+ ProcessList *process_list = control_flow_data->process_list;
LttField *f = ltt_event_field(e);
//LttTime time = ltt_event_time(e);
- //LttTime window_end = ltt_time_add(time_window->time_width,
- // time_window->start_time);
+ //LttTime window_end = time_window->time_window.end_time;
//convert_time_to_pixels(
- // time_window->start_time,
- // window_end,
+ // *time_window,
// time,
// width,
// &x);
#endif //0
}
-static __inline PropertiesLine prepare_execmode_line(LttvProcessState *process)
+#if 0
+static __inline__ PropertiesLine prepare_execmode_line(LttvProcessState *process)
{
PropertiesLine prop_line;
prop_line.line_width = 1;
return prop_line;
}
-
+#endif //0
/* before_execmode_hook
LttvTracefileContext *tfc = (LttvTracefileContext *)call_data;
LttvTracefileState *tfs = (LttvTracefileState *)call_data;
- LttvTraceState *ts =(LttvTraceState *)LTTV_TRACEFILE_CONTEXT(tfs)->t_context;
+ LttvTraceState *ts =(LttvTraceState *)((LttvTracefileContext*)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
/* 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);
+ ProcessList *process_list = control_flow_data->process_list;
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,
+
+ if(process_list->current_hash_data[tfc->index] != NULL) {
+ hashed_process_data = process_list->current_hash_data[tfc->index];
+ processlist_get_pixels_from_data(process_list,
+ hashed_process_data,
+ &y,
+ &height);
+ } else {
+ if(processlist_get_process_pixels(process_list,
pid,
- process->last_cpu,
+ process->last_cpu_index,
&birth,
tfc->t_context->index,
&y,
&height,
- &hashed_process_data);
- drawing_insert_square( drawing, y, height);
+ &hashed_process_data) == 1)
+ {
+ g_assert(pid == 0 || pid != process->ppid);
+ ProcessInfo *process_info;
+ /* Process not present */
+ const gchar *name = g_quark_to_string(process->name);
+ processlist_add(process_list,
+ pid,
+ process->last_cpu_index,
+ process->ppid,
+ &birth,
+ tfc->t_context->index,
+ name,
+ &pl_height,
+ &process_info,
+ &hashed_process_data);
+ processlist_get_pixels_from_data(process_list,
+ hashed_process_data,
+ &y,
+ &height);
+ drawing_insert_square( drawing, y, height);
+ }
+ /* Set the current process */
+ process_list->current_hash_data[process->last_cpu_index] =
+ hashed_process_data;
}
/* Now, the process is in the state hash and our own process hash.
* value.
*/
g_assert(hashed_process_data->x.over != -1);
+
+ if(ltt_time_compare(hashed_process_data->next_good_time,
+ evtime) > 0)
{
+ if(hashed_process_data->x.middle_marked == FALSE) {
+ TimeWindow time_window =
+ lttvwindow_get_time_window(control_flow_data->tab);
+
+#ifdef EXTRA_CHECK
+ if(ltt_time_compare(evtime, time_window.start_time) == -1
+ || ltt_time_compare(evtime, time_window.end_time) == 1)
+ return;
+#endif //EXTRA_CHECK
+ guint x;
+ convert_time_to_pixels(
+ time_window,
+ evtime,
+ width,
+ &x);
+
+ /* Draw collision indicator */
+ gdk_gc_set_foreground(drawing->gc, &drawing_colors[COL_WHITE]);
+ gdk_draw_point(drawing->pixmap,
+ drawing->gc,
+ x,
+ y+(height/2)-3);
+ hashed_process_data->x.middle_marked = TRUE;
+ }
+ } else {
+ TimeWindow time_window =
+ lttvwindow_get_time_window(control_flow_data->tab);
+
+#ifdef EXTRA_CHECK
+ if(ltt_time_compare(evtime, time_window.start_time) == -1
+ || ltt_time_compare(evtime, time_window.end_time) == 1)
+ return;
+#endif //EXTRA_CHECK
guint x;
convert_time_to_pixels(
- time_window.start_time,
- end_time,
+ time_window,
evtime,
width,
&x);
/* Jump over draw if we are at the same x position */
- if(x == hashed_process_data->x.over)
+ 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+(height/2)-3);
+ hashed_process_data->x.middle_marked = TRUE;
+ }
/* jump */
} else {
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.over;
+ draw_context.drawinfo.start.x = hashed_process_data->x.middle;
draw_context.drawinfo.end.x = x;
draw_context.drawinfo.y.over = y+1;
{
/* Draw the line */
- PropertiesLine prop_line = prepare_execmode_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.over = x;
+ hashed_process_data->x.middle = x;
+ hashed_process_data->x.middle_used = TRUE;
+ hashed_process_data->x.middle_marked = FALSE;
+
+ /* Calculate the next good time */
+ convert_pixels_to_time(width, x+1, time_window,
+ &hashed_process_data->next_good_time);
}
}
LttvTracefileContext *tfc = (LttvTracefileContext *)call_data;
LttvTracefileState *tfs = (LttvTracefileState *)call_data;
- LttvTraceState *ts =(LttvTraceState *)LTTV_TRACEFILE_CONTEXT(tfs)->t_context;
+ LttvTraceState *ts =(LttvTraceState *)((LttvTracefileContext*)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) */
guint y = 0, height = 0, pl_height = 0;
HashedProcessData *hashed_process_data = NULL;
- ProcessList *process_list =
- guicontrolflow_get_process_list(control_flow_data);
-
+ ProcessList *process_list = control_flow_data->process_list;
/* Find process pid_in in the list... */
process = tfs->process;
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,
+ if(process_list->current_hash_data[tfc->index] != NULL) {
+ hashed_process_data = process_list->current_hash_data[tfc->index];
+ processlist_get_pixels_from_data(process_list,
+ hashed_process_data,
+ &y,
+ &height);
+ } else {
+ if(processlist_get_process_pixels(process_list,
pid,
- process->last_cpu,
+ process->last_cpu_index,
&birth,
tfc->t_context->index,
&y,
&height,
- &hashed_process_data);
- drawing_insert_square( control_flow_data->drawing, y, height);
+ &hashed_process_data) == 1)
+ {
+ g_assert(pid == 0 || pid != process->ppid);
+ /* Process not present */
+ const gchar *name = g_quark_to_string(process->name);
+ ProcessInfo *process_info;
+ processlist_add(process_list,
+ pid,
+ process->last_cpu_index,
+ process->ppid,
+ &birth,
+ tfc->t_context->index,
+ name,
+ &pl_height,
+ &process_info,
+ &hashed_process_data);
+ processlist_get_pixels_from_data(process_list,
+ hashed_process_data,
+ &y,
+ &height);
+ drawing_insert_square( control_flow_data->drawing, y, height);
+ }
+ /* Set the current process */
+ process_list->current_hash_data[process->last_cpu_index] =
+ hashed_process_data;
}
- convert_time_to_pixels(
- time_window.start_time,
- end_time,
- evtime,
- width,
- &hashed_process_data->x.over);
+ if(ltt_time_compare(hashed_process_data->next_good_time,
+ evtime) <= 0)
+ {
+ TimeWindow time_window =
+ lttvwindow_get_time_window(control_flow_data->tab);
+
+#ifdef EXTRA_CHECK
+ if(ltt_time_compare(evtime, time_window.start_time) == -1
+ || ltt_time_compare(evtime, time_window.end_time) == 1)
+ return;
+#endif //EXTRA_CHECK
+
+
+ guint new_x;
+
+ convert_time_to_pixels(
+ time_window,
+ 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;
}
LttvTracefileContext *tfc = (LttvTracefileContext *)call_data;
LttvTracefileState *tfs = (LttvTracefileState *)call_data;
- LttvTraceState *ts =(LttvTraceState *)LTTV_TRACEFILE_CONTEXT(tfs)->t_context;
+ LttvTraceState *ts =(LttvTraceState *)((LttvTracefileContext*)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 y = 0, height = 0, pl_height = 0;
HashedProcessData *hashed_process_data = NULL;
- ProcessList *process_list =
- guicontrolflow_get_process_list(control_flow_data);
+ ProcessList *process_list = control_flow_data->process_list;
g_assert(process != NULL);
birth = process->creation_time;
- const gchar *name = g_quark_to_string(process->name);
- if(processlist_get_process_pixels(process_list,
+ if(process_list->current_hash_data[tfc->index] != NULL) {
+ hashed_process_data = process_list->current_hash_data[tfc->index];
+ processlist_get_pixels_from_data(process_list,
+ hashed_process_data,
+ &y,
+ &height);
+ } else if(processlist_get_process_pixels(process_list,
pid,
- process->last_cpu,
+ process->last_cpu_index,
&birth,
tfc->t_context->index,
&y,
{
g_assert(pid == 0 || pid != process->ppid);
/* Process not present */
+ const gchar *name = g_quark_to_string(process->name);
+ ProcessInfo *process_info;
processlist_add(process_list,
pid,
- process->last_cpu,
+ process->last_cpu_index,
process->ppid,
&birth,
tfc->t_context->index,
name,
&pl_height,
+ &process_info,
&hashed_process_data);
- processlist_get_process_pixels(process_list,
- pid,
- process->last_cpu,
- &birth,
- tfc->t_context->index,
- &y,
- &height,
- &hashed_process_data);
+ processlist_get_pixels_from_data(process_list,
+ hashed_process_data,
+ &y,
+ &height);
drawing_insert_square( control_flow_data->drawing, y, height);
}
* value.
*/
g_assert(hashed_process_data->x.over != -1);
+
+ if(ltt_time_compare(hashed_process_data->next_good_time,
+ evtime) > 0)
{
+ if(hashed_process_data->x.middle_marked == FALSE) {
+ TimeWindow time_window =
+ lttvwindow_get_time_window(control_flow_data->tab);
+
+#ifdef EXTRA_CHECK
+ if(ltt_time_compare(evtime, time_window.start_time) == -1
+ || ltt_time_compare(evtime, time_window.end_time) == 1)
+ return;
+#endif //EXTRA_CHECK
+
+ guint x;
+ convert_time_to_pixels(
+ time_window,
+ evtime,
+ width,
+ &x);
+
+ /* Draw collision indicator */
+ gdk_gc_set_foreground(drawing->gc, &drawing_colors[COL_WHITE]);
+ gdk_draw_point(drawing->pixmap,
+ drawing->gc,
+ x,
+ y+(height/2)-3);
+ hashed_process_data->x.middle_marked = TRUE;
+ }
+ } else {
+ TimeWindow time_window =
+ lttvwindow_get_time_window(control_flow_data->tab);
+
+#ifdef EXTRA_CHECK
+ if(ltt_time_compare(evtime, time_window.start_time) == -1
+ || ltt_time_compare(evtime, time_window.end_time) == 1)
+ return;
+#endif //EXTRA_CHECK
+
guint x;
convert_time_to_pixels(
- time_window.start_time,
- end_time,
+ time_window,
evtime,
width,
&x);
/* Jump over draw if we are at the same x position */
- if(x == hashed_process_data->x.middle)
- {
+ 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+(height/2)-3);
+ hashed_process_data->x.middle_marked = TRUE;
+ }
/* jump */
} else {
DrawContext draw_context;
{
/* 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.middle = x;
+ hashed_process_data->x.middle_used = TRUE;
+ hashed_process_data->x.middle_marked = FALSE;
+
+ /* Calculate the next good time */
+ convert_pixels_to_time(width, x+1, time_window,
+ &hashed_process_data->next_good_time);
}
}
LttvTracefileContext *tfc = (LttvTracefileContext *)call_data;
LttvTracefileState *tfs = (LttvTracefileState *)call_data;
- LttvTraceState *ts =(LttvTraceState *)LTTV_TRACEFILE_CONTEXT(tfs)->t_context;
+ LttvTraceState *ts =(LttvTraceState *)((LttvTracefileContext*)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 y_child = 0, height = 0, pl_height = 0;
HashedProcessData *hashed_process_data_child = NULL;
- ProcessList *process_list =
- guicontrolflow_get_process_list(control_flow_data);
-
+ ProcessList *process_list = control_flow_data->process_list;
/* Find child in the list... */
process_child = lttv_state_find_process(tfs, child_pid);
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,
+ process_child->last_cpu_index,
&birth,
tfc->t_context->index,
&y_child,
{
g_assert(child_pid == 0 || child_pid != process_child->ppid);
/* Process not present */
+ const gchar *name = g_quark_to_string(process_child->name);
+ ProcessInfo *process_info;
processlist_add(process_list,
child_pid,
- process_child->last_cpu,
+ process_child->last_cpu_index,
process_child->ppid,
&birth,
tfc->t_context->index,
name,
&pl_height,
+ &process_info,
&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);
+ processlist_get_pixels_from_data(process_list,
+ hashed_process_data_child,
+ &y_child,
+ &height);
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);
- hashed_process_data_child->x.over = new_x;
- hashed_process_data_child->x.middle = new_x;
- hashed_process_data_child->x.under = new_x;
+
+ if(ltt_time_compare(hashed_process_data_child->next_good_time,
+ evtime) <= 0)
+ {
+ TimeWindow time_window =
+ lttvwindow_get_time_window(control_flow_data->tab);
+
+#ifdef EXTRA_CHECK
+ if(ltt_time_compare(evtime, time_window.start_time) == -1
+ || ltt_time_compare(evtime, time_window.end_time) == 1)
+ return;
+#endif //EXTRA_CHECK
+
+ guint new_x;
+ convert_time_to_pixels(
+ time_window,
+ 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 */
guint y = 0, height = 0, pl_height = 0;
HashedProcessData *hashed_process_data = NULL;
- ProcessList *process_list =
- guicontrolflow_get_process_list(control_flow_data);
-
+ ProcessList *process_list = control_flow_data->process_list;
/* 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,
- &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,
+ if(process_list->current_hash_data[tfc->index] != NULL) {
+ hashed_process_data = process_list->current_hash_data[tfc->index];
+ processlist_get_pixels_from_data(process_list,
+ hashed_process_data,
+ &y,
+ &height);
+
+ } else {
+ if(processlist_get_process_pixels(process_list,
pid,
- process->last_cpu,
+ process->last_cpu_index,
&birth,
tfc->t_context->index,
&y,
&height,
- &hashed_process_data);
- drawing_insert_square( control_flow_data->drawing, y, height);
+ &hashed_process_data) == 1)
+ {
+ g_assert(pid == 0 || pid != process->ppid);
+ /* Process not present */
+ const gchar *name = g_quark_to_string(process->name);
+ ProcessInfo *process_info;
+ processlist_add(process_list,
+ pid,
+ process->last_cpu_index,
+ process->ppid,
+ &birth,
+ tfc->t_context->index,
+ name,
+ &pl_height,
+ &process_info,
+ &hashed_process_data);
+ processlist_get_pixels_from_data(process_list,
+ hashed_process_data,
+ &y,
+ &height);
+ drawing_insert_square( control_flow_data->drawing, y, height);
+ }
+
+ /* Set the current process */
+ process_list->current_hash_data[process->last_cpu_index] =
+ hashed_process_data;
+ }
+
+ if(ltt_time_compare(hashed_process_data->next_good_time,
+ evtime) <= 0)
+ {
+ TimeWindow time_window =
+ lttvwindow_get_time_window(control_flow_data->tab);
+
+#ifdef EXTRA_CHECK
+ if(ltt_time_compare(evtime, time_window.start_time) == -1
+ || ltt_time_compare(evtime, time_window.end_time) == 1)
+ return;
+#endif //EXTRA_CHECK
+
+ guint new_x;
+ convert_time_to_pixels(
+ time_window,
+ 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;
+ }
}
- guint new_x;
- convert_time_to_pixels(
- time_window.start_time,
- end_time,
- evtime,
- width,
- &new_x);
- hashed_process_data->x.middle = new_x;
}
return 0;
/* Same scale (scrolling) */
g_info("scrolling");
LttTime *ns = &new_time_window->start_time;
+ LttTime *nw = &new_time_window->time_width;
LttTime *os = &old_time_window->start_time;
- LttTime old_end = ltt_time_add(old_time_window->start_time,
- old_time_window->time_width);
- LttTime new_end = ltt_time_add(new_time_window->start_time,
- new_time_window->time_width);
+ LttTime *ow = &old_time_window->time_width;
+ LttTime old_end = old_time_window->end_time;
+ LttTime new_end = new_time_window->end_time;
//if(ns<os+w<ns+w)
//if(ns<os+w && os+w<ns+w)
//if(ns<old_end && os<ns)
guint x = 0;
guint width = control_flow_data->drawing->width;
convert_time_to_pixels(
- *os,
- old_end,
+ *old_time_window,
*ns,
width,
&x);
guint x = 0;
guint width = control_flow_data->drawing->width;
convert_time_to_pixels(
- *ns,
- new_end,
+ *new_time_window,
*os,
width,
&x);
new_time_window.start_time = time_begin;
new_time_window.time_width = width;
+ new_time_window.time_width_double = ltt_time_to_double(width);
+ new_time_window.end_time = ltt_time_add(time_begin, width);
lttvwindow_report_time_window(control_flow_data->tab, new_time_window);
}
new_time_window.start_time = time_begin;
new_time_window.time_width = width;
+ new_time_window.time_width_double = ltt_time_to_double(width);
+ new_time_window.end_time = ltt_time_add(time_begin, width);
lttvwindow_report_time_window(control_flow_data->tab, new_time_window);
LttvTracesetContext *tsc = (LttvTracesetContext*)closure_data->tss;
LttTime evtime = closure_data->end_time;
- 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;
{
* 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. */
+#ifdef EXTRA_CHECK
g_assert(lttv_traceset_number(tsc->ts) > 0);
-
+#endif //EXTRA_CHECK
/* tracefiles[0] is ok here, because we draw for every PID, and
* assume CPU 0 for PID 0 //FIXME */
LttvTracefileState *tfs =
/* Only draw for processes that are currently in the trace states */
guint y = 0, height = 0, pl_height = 0;
- ProcessList *process_list =
- guicontrolflow_get_process_list(control_flow_data);
+ ProcessList *process_list = control_flow_data->process_list;
LttTime birth = process_info->birth;
/* Should be alike when background info is ready */
if(control_flow_data->background_info_waiting==0)
g_assert(ltt_time_compare(process->creation_time,
process_info->birth) == 0);
- const gchar *name = g_quark_to_string(process->name);
-
/* process HAS to be present */
- g_assert(processlist_get_process_pixels(process_list,
- process_info->pid,
- process_info->cpu,
- &birth,
- process_info->trace_num,
+ processlist_get_pixels_from_data(process_list,
+ hashed_process_data,
&y,
- &height,
- &hashed_process_data) != 1);
+ &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.
* value.
*/
g_assert(hashed_process_data->x.over != -1);
+
+ if(ltt_time_compare(hashed_process_data->next_good_time,
+ evtime) <= 0)
{
+ TimeWindow time_window =
+ lttvwindow_get_time_window(control_flow_data->tab);
+
+#ifdef EXTRA_CHECK
+ if(ltt_time_compare(evtime, time_window.start_time) == -1
+ || ltt_time_compare(evtime, time_window.end_time) == 1)
+ return;
+#endif //EXTRA_CHECK
guint x;
convert_time_to_pixels(
- time_window.start_time,
- end_time,
+ time_window,
evtime,
width,
&x);
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)
{
hashed_process_data->x.over = x;
}
+#endif //0
- if(x == hashed_process_data->x.middle) {
+ if(x == hashed_process_data->x.middle &&
+ hashed_process_data->x.middle_used) {
+#if 0 /* do not mark closure : not missing information */
+ 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+(height/2)-3);
+ hashed_process_data->x.middle_marked = TRUE;
+ }
+#endif //0
/* Jump */
} else {
draw_context.drawinfo.start.x = hashed_process_data->x.middle;
/* 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.middle = x;
+ 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;
+
+ /* Calculate the next good time */
+ convert_pixels_to_time(width, x+1, time_window,
+ &hashed_process_data->next_good_time);
+ }
}
}
}
int before_chunk(void *hook_data, void *call_data)
{
EventsRequest *events_request = (EventsRequest*)hook_data;
- LttvTracesetState *tss = LTTV_TRACESET_STATE(call_data);
+ LttvTracesetState *tss = (LttvTracesetState*)call_data;
drawing_chunk_begin(events_request, tss);
int before_request(void *hook_data, void *call_data)
{
EventsRequest *events_request = (EventsRequest*)hook_data;
- LttvTracesetState *tss = LTTV_TRACESET_STATE(call_data);
+ LttvTracesetState *tss = (LttvTracesetState*)call_data;
drawing_data_request_begin(events_request, tss);
{
EventsRequest *events_request = (EventsRequest*)hook_data;
ControlFlowData *control_flow_data = events_request->viewer_data;
- LttvTracesetState *tss = LTTV_TRACESET_STATE(call_data);
- LttvTracesetContext *tsc = LTTV_TRACESET_CONTEXT(call_data);
+ LttvTracesetState *tss = (LttvTracesetState*)call_data;
+ LttvTracesetContext *tsc = (LttvTracesetContext*)call_data;
- ProcessList *process_list =
- guicontrolflow_get_process_list(control_flow_data);
+ ProcessList *process_list = control_flow_data->process_list;
LttTime end_time = events_request->end_time;
ClosureData closure_data;
{
EventsRequest *events_request = (EventsRequest*)hook_data;
ControlFlowData *control_flow_data = events_request->viewer_data;
- LttvTracesetState *tss = LTTV_TRACESET_STATE(call_data);
- LttvTracesetContext *tsc = LTTV_TRACESET_CONTEXT(call_data);
+ LttvTracesetState *tss = (LttvTracesetState*)call_data;
+ LttvTracesetContext *tsc = (LttvTracesetContext*)call_data;
LttvTracefileContext *tfc = lttv_traceset_context_get_current_tfc(tsc);
LttTime end_time;
- ProcessList *process_list =
- guicontrolflow_get_process_list(control_flow_data);
+ ProcessList *process_list = control_flow_data->process_list;
+ g_free(process_list->current_hash_data);
+ process_list->current_hash_data = NULL;
+
if(tfc != NULL)
end_time = LTT_TIME_MIN(tfc->timestamp, events_request->end_time);
else /* end of traceset, or position now out of request : end */
projects / lttv.git / blobdiff