* Wait for all the awaited computations to be over.
*/
-gint background_ready(void *hook_data, void *call_data)
+static gint background_ready(void *hook_data, void *call_data)
{
ControlFlowData *control_flow_data = (ControlFlowData *)hook_data;
LttvTrace *trace = (LttvTrace*)call_data;
* information. Happens when two viewers ask for it before servicing
* starts.
*/
- lttvwindowtraces_background_request_remove(trace, "state");
- lttvwindowtraces_background_request_queue(trace,
- "state");
+ if(!lttvwindowtraces_background_request_find(trace, "state"))
+ lttvwindowtraces_background_request_queue(
+ main_window_get_widget(control_flow_data->tab), trace, "state");
lttvwindowtraces_background_notify_queue(control_flow_data,
trace,
ltt_time_infinite,
}
} else {
/* Data ready. Be its nature, this viewer doesn't need to have
- * its data ready hook called htere, because a background
+ * its data ready hook called there, because a background
* request is always linked with a redraw.
*/
}
h_guicontrolflow(Tab *tab)
{
g_info("h_guicontrolflow, %p", tab);
- ControlFlowData *control_flow_data = guicontrolflow() ;
+ ControlFlowData *control_flow_data = guicontrolflow(tab) ;
control_flow_data->tab = tab;
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_SOFT_IRQ)
+ prop_line.color = drawing_colors[COL_RUN_SOFT_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_EXIT];
} else if(process->state->s == LTTV_STATE_UNNAMED) {
prop_line.color = drawing_colors[COL_UNNAMED];
- } else
+ } else {
+ g_critical("unknown state : %s", g_quark_to_string(process->state->s));
g_assert(FALSE); /* UNKNOWN STATE */
+ }
return prop_line;
}
+/* after_event_enum_process_hook
+ *
+ * DOES EXACTLY THE SAME AS after_schedchange_hook, for the "in" process.
+ * 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_event_enum_process_hook(void *hook_data, void *call_data)
+{
+ LttvTraceHookByFacility *thf = (LttvTraceHookByFacility*)hook_data;
+ EventsRequest *events_request = (EventsRequest*)thf->hook_data;
+ ControlFlowData *control_flow_data = events_request->viewer_data;
+
+ LttvTracefileContext *tfc = (LttvTracefileContext *)call_data;
+
+ LttvTracefileState *tfs = (LttvTracefileState *)call_data;
+
+ LttvTraceState *ts = (LttvTraceState *)tfc->t_context;
+
+ LttEvent *e;
+ e = ltt_tracefile_get_event(tfc->tf);
+
+ LttTime evtime = ltt_event_time(e);
+
+ /* Add process to process list (if not present) */
+ LttvProcessState *process_in;
+ LttTime birth;
+ guint pl_height = 0;
+ HashedProcessData *hashed_process_data_in = NULL;
+
+ ProcessList *process_list = control_flow_data->process_list;
+
+ guint pid_in;
+ {
+ pid_in = ltt_event_get_long_unsigned(e, thf->f1);
+ }
+ /* Find process pid_in in the list... */
+ process_in = lttv_state_find_process(ts, ANY_CPU, pid_in);
+ //process_in = tfs->process;
+ //guint cpu = ltt_tracefile_num(tfc->tf);
+ //process_in = ts->running_process[cpu];
+ /* It should exist, because we are after the state update. */
+#ifdef EXTRA_CHECK
+ //g_assert(process_in != NULL);
+#endif //EXTRA_CHECK
+ birth = process_in->creation_time;
+
+ hashed_process_data_in = processlist_get_process_data(process_list,
+ pid_in,
+ process_in->cpu,
+ &birth,
+ tfc->t_context->index);
+ if(hashed_process_data_in == NULL)
+ {
+ if(pid_in != 0 && pid_in == process_in->ppid)
+ g_critical("TEST %u , %u", pid_in, process_in->ppid);
+ g_assert(pid_in == 0 || pid_in != process_in->ppid);
+ ProcessInfo *process_info;
+ Drawing_t *drawing = control_flow_data->drawing;
+ /* Process not present */
+ processlist_add(process_list,
+ drawing,
+ pid_in,
+ process_in->cpu,
+ process_in->ppid,
+ &birth,
+ tfc->t_context->index,
+ process_in->name,
+ &pl_height,
+ &process_info,
+ &hashed_process_data_in);
+ gtk_widget_set_size_request(drawing->drawing_area,
+ -1,
+ pl_height);
+ gtk_widget_queue_draw(drawing->drawing_area);
+ }
+ /* Set the current process */
+ process_list->current_hash_data[process_in->cpu] =
+ hashed_process_data_in;
+
+ 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
+ Drawing_t *drawing = control_flow_data->drawing;
+ guint width = drawing->width;
+ 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;
+}
+
gint update_time_window_hook(void *hook_data, void *call_data)
{
control_flow_data->drawing->height);
}
+ /* Update directly when scrolling */
+ gdk_window_process_updates(control_flow_data->drawing->drawing_area->window,
+ TRUE);
-
return 0;
}
ControlFlowData *control_flow_data = (ControlFlowData*) hook_data;
Drawing_t *drawing = control_flow_data->drawing;
+ if(unlikely(drawing->gc == NULL)) {
+ return FALSE;
+ }
+ if(drawing->dotted_gc == NULL) {
+ return FALSE;
+ }
drawing_clear(control_flow_data->drawing);
processlist_clear(control_flow_data->process_list);
}
gtk_widget_queue_draw(control_flow_data->drawing->drawing_area);
-
+ /* Update directly when scrolling */
+ gdk_window_process_updates(control_flow_data->drawing->drawing_area->window,
+ TRUE);
+
return 0;
}
projects / lttv.git / blobdiff