X-Git-Url: http://git.lttng.org./?a=blobdiff_plain;f=ltt%2Fbranches%2Fpoly%2Flttv%2Fmodules%2Fgui%2Fcontrolflow%2Feventhooks.c;h=a322c5d535e81ec94574c591f1382cb4c5b87699;hb=088f6772c700cf75d4ba27adf086dc37d961a960;hp=5fd3fd11b6b252acd9306280b75d45f78ace5b8a;hpb=de738e2522710e9eb263107e351a66e1643d0326;p=lttv.git diff --git a/ltt/branches/poly/lttv/modules/gui/controlflow/eventhooks.c b/ltt/branches/poly/lttv/modules/gui/controlflow/eventhooks.c index 5fd3fd11..a322c5d5 100644 --- a/ltt/branches/poly/lttv/modules/gui/controlflow/eventhooks.c +++ b/ltt/branches/poly/lttv/modules/gui/controlflow/eventhooks.c @@ -45,6 +45,9 @@ * line/background. */ +#ifdef HAVE_CONFIG_H +#include +#endif //#define PANGO_ENABLE_BACKEND #include @@ -59,6 +62,7 @@ #include #include #include +#include #include #include @@ -75,7 +79,6 @@ #define MAX_PATH_LEN 256 - #if 0 typedef struct _ProcessAddClosure { ControlFlowData *cfd; @@ -149,6 +152,9 @@ gint background_ready(void *hook_data, void *call_data) drawing_clear(control_flow_data->drawing); processlist_clear(control_flow_data->process_list); + gtk_widget_set_size_request( + control_flow_data->drawing->drawing_area, + -1, processlist_get_height(control_flow_data->process_list)); redraw_notify(control_flow_data, NULL); } @@ -372,7 +378,8 @@ static inline PropertiesLine prepare_status_line(LttvProcessState *process) int before_schedchange_hook(void *hook_data, void *call_data) { - EventsRequest *events_request = (EventsRequest*)hook_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; @@ -380,7 +387,7 @@ int before_schedchange_hook(void *hook_data, void *call_data) LttvTracefileState *tfs = (LttvTracefileState *)call_data; LttEvent *e; - e = tfc->e; + e = ltt_tracefile_get_event(tfc->tf); LttTime evtime = ltt_event_time(e); @@ -392,12 +399,8 @@ int before_schedchange_hook(void *hook_data, void *call_data) 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); + pid_out = ltt_event_get_long_unsigned(e, thf->f1); + pid_in = ltt_event_get_long_unsigned(e, thf->f2); } { @@ -419,7 +422,7 @@ int before_schedchange_hook(void *hook_data, void *call_data) * or add it, and draw its items. */ /* Add process to process list (if not present) */ - guint y = 0, height = 0, pl_height = 0; + guint pl_height = 0; HashedProcessData *hashed_process_data = NULL; ProcessList *process_list = control_flow_data->process_list; LttTime birth = process->creation_time; @@ -435,7 +438,9 @@ int before_schedchange_hook(void *hook_data, void *call_data) const gchar *name = g_quark_to_string(process->name); /* Process not present */ ProcessInfo *process_info; + Drawing_t *drawing = control_flow_data->drawing; processlist_add(process_list, + drawing, pid_out, process->last_cpu_index, process->ppid, @@ -445,11 +450,11 @@ int before_schedchange_hook(void *hook_data, void *call_data) &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); + gtk_widget_set_size_request(drawing->drawing_area, + -1, + pl_height); + gtk_widget_queue_draw(drawing->drawing_area); + } /* Now, the process is in the state hash and our own process hash. @@ -460,10 +465,6 @@ int before_schedchange_hook(void *hook_data, void *call_data) evtime) > 0) { if(hashed_process_data->x.middle_marked == FALSE) { - processlist_get_pixels_from_data(process_list, - hashed_process_data, - &y, - &height); TimeWindow time_window = lttvwindow_get_time_window(control_flow_data->tab); @@ -483,19 +484,13 @@ int before_schedchange_hook(void *hook_data, void *call_data) /* Draw collision indicator */ gdk_gc_set_foreground(drawing->gc, &drawing_colors[COL_WHITE]); - gdk_draw_point(drawing->pixmap, + gdk_draw_point(hashed_process_data->pixmap, drawing->gc, x, - y+(height/2)-3); + (hashed_process_data->height/2)-3); hashed_process_data->x.middle_marked = TRUE; } } else { - processlist_get_pixels_from_data(process_list, - hashed_process_data, - &y, - &height); - - TimeWindow time_window = lttvwindow_get_time_window(control_flow_data->tab); #ifdef EXTRA_CHECK @@ -520,10 +515,10 @@ int before_schedchange_hook(void *hook_data, void *call_data) 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, + gdk_draw_point(hashed_process_data->pixmap, drawing->gc, x, - y+(height/2)-3); + (hashed_process_data->height/2)-3); hashed_process_data->x.middle_marked = TRUE; } /* jump */ @@ -532,15 +527,15 @@ int before_schedchange_hook(void *hook_data, void *call_data) /* Now create the drawing context that will be used to draw * items related to the last state. */ - draw_context.drawable = drawing->pixmap; + draw_context.drawable = hashed_process_data->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.y.over = 1; + draw_context.drawinfo.y.middle = (hashed_process_data->height/2); + draw_context.drawinfo.y.under = hashed_process_data->height; draw_context.drawinfo.start.offset.over = 0; draw_context.drawinfo.start.offset.middle = 0; @@ -583,7 +578,7 @@ int before_schedchange_hook(void *hook_data, void *call_data) * or add it, and draw its items. */ /* Add process to process list (if not present) */ - guint y = 0, height = 0, pl_height = 0; + guint pl_height = 0; HashedProcessData *hashed_process_data = NULL; ProcessList *process_list = control_flow_data->process_list; LttTime birth = process->creation_time; @@ -599,7 +594,9 @@ int before_schedchange_hook(void *hook_data, void *call_data) const gchar *name = g_quark_to_string(process->name); /* Process not present */ ProcessInfo *process_info; + Drawing_t *drawing = control_flow_data->drawing; processlist_add(process_list, + drawing, pid_in, process->last_cpu_index, process->ppid, @@ -609,11 +606,11 @@ int before_schedchange_hook(void *hook_data, void *call_data) &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); + gtk_widget_set_size_request(drawing->drawing_area, + -1, + pl_height); + gtk_widget_queue_draw(drawing->drawing_area); + } //We could set the current process and hash here, but will be done //by after schedchange hook @@ -627,10 +624,6 @@ int before_schedchange_hook(void *hook_data, void *call_data) { if(hashed_process_data->x.middle_marked == FALSE) { - processlist_get_pixels_from_data(process_list, - hashed_process_data, - &y, - &height); TimeWindow time_window = lttvwindow_get_time_window(control_flow_data->tab); #ifdef EXTRA_CHECK @@ -649,17 +642,13 @@ int before_schedchange_hook(void *hook_data, void *call_data) /* Draw collision indicator */ gdk_gc_set_foreground(drawing->gc, &drawing_colors[COL_WHITE]); - gdk_draw_point(drawing->pixmap, + gdk_draw_point(hashed_process_data->pixmap, drawing->gc, x, - y+(height/2)-3); + (hashed_process_data->height/2)-3); hashed_process_data->x.middle_marked = TRUE; } } else { - processlist_get_pixels_from_data(process_list, - hashed_process_data, - &y, - &height); TimeWindow time_window = lttvwindow_get_time_window(control_flow_data->tab); #ifdef EXTRA_CHECK @@ -685,10 +674,10 @@ int before_schedchange_hook(void *hook_data, void *call_data) 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, + gdk_draw_point(hashed_process_data->pixmap, drawing->gc, x, - y+(height/2)-3); + (hashed_process_data->height/2)-3); hashed_process_data->x.middle_marked = TRUE; } /* jump */ @@ -697,15 +686,15 @@ int before_schedchange_hook(void *hook_data, void *call_data) /* Now create the drawing context that will be used to draw * items related to the last state. */ - draw_context.drawable = drawing->pixmap; + draw_context.drawable = hashed_process_data->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.y.over = 1; + draw_context.drawinfo.y.middle = (hashed_process_data->height/2); + draw_context.drawinfo.y.under = hashed_process_data->height; draw_context.drawinfo.start.offset.over = 0; draw_context.drawinfo.start.offset.middle = 0; @@ -926,7 +915,7 @@ int before_schedchange_hook(void *hook_data, void *call_data) PropertiesBG prop_bg; prop_bg.color = g_new(GdkColor,1); - switch(tfc->index) { + switch(ltt_tracefile_num(tfc->tf)) { case 0: prop_bg.color->red = 0x1515; prop_bg.color->green = 0x1515; @@ -1149,7 +1138,7 @@ int before_schedchange_hook(void *hook_data, void *call_data) PropertiesBG prop_bg; prop_bg.color = g_new(GdkColor,1); - switch(tfc->index) { + switcht(ltt_tracefile_num(tfc->tf)) { case 0: prop_bg.color->red = 0x1515; prop_bg.color->green = 0x1515; @@ -1356,7 +1345,8 @@ int before_schedchange_hook(void *hook_data, void *call_data) */ int after_schedchange_hook(void *hook_data, void *call_data) { - EventsRequest *events_request = (EventsRequest*)hook_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; @@ -1364,14 +1354,14 @@ int after_schedchange_hook(void *hook_data, void *call_data) LttvTracefileState *tfs = (LttvTracefileState *)call_data; LttEvent *e; - e = tfc->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 y_in = 0, height = 0, pl_height = 0; + guint pl_height = 0; HashedProcessData *hashed_process_data_in = NULL; ProcessList *process_list = control_flow_data->process_list; @@ -1379,12 +1369,8 @@ int after_schedchange_hook(void *hook_data, void *call_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); + pid_out = ltt_event_get_long_unsigned(e, thf->f1); + pid_in = ltt_event_get_long_unsigned(e, thf->f2); } @@ -1407,8 +1393,10 @@ int after_schedchange_hook(void *hook_data, void *call_data) g_assert(pid_in == 0 || pid_in != process_in->ppid); const gchar *name = g_quark_to_string(process_in->name); ProcessInfo *process_info; + Drawing_t *drawing = control_flow_data->drawing; /* Process not present */ processlist_add(process_list, + drawing, pid_in, process_in->last_cpu_index, process_in->ppid, @@ -1418,11 +1406,10 @@ int after_schedchange_hook(void *hook_data, void *call_data) &pl_height, &process_info, &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); + 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->last_cpu_index] = @@ -1431,10 +1418,6 @@ int after_schedchange_hook(void *hook_data, void *call_data) if(ltt_time_compare(hashed_process_data_in->next_good_time, evtime) <= 0) { - processlist_get_pixels_from_data(process_list, - hashed_process_data_in, - &y_in, - &height); TimeWindow time_window = lttvwindow_get_time_window(control_flow_data->tab); @@ -1864,7 +1847,7 @@ int after_schedchange_hook(void *hook_data, void *call_data) prop_text_in.text = g_new(gchar, 260); strcpy(prop_text_in.text, "CPU "); - snprintf(tmp, 255, "%u", tfc->index); + snprintf(tmp, 255, "%u", ltt_tracefile_num(tfc->tf)); strcat(prop_text_in.text, tmp); draw_text((void*)&prop_text_in, (void*)draw_context_in); @@ -1969,7 +1952,9 @@ static inline PropertiesLine prepare_execmode_line(LttvProcessState *process) int before_execmode_hook(void *hook_data, void *call_data) { - EventsRequest *events_request = (EventsRequest*)hook_data; + return 0; //DISABLED + 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; @@ -1977,7 +1962,7 @@ int before_execmode_hook(void *hook_data, void *call_data) LttvTracefileState *tfs = (LttvTracefileState *)call_data; LttEvent *e; - e = tfc->e; + e = ltt_tracefile_get_event(tfc->tf); LttTime evtime = ltt_event_time(e); @@ -1995,13 +1980,13 @@ int before_execmode_hook(void *hook_data, void *call_data) * or add it, and draw its items. */ /* Add process to process list (if not present) */ - guint y = 0, height = 0, pl_height = 0; + guint pl_height = 0; HashedProcessData *hashed_process_data = NULL; ProcessList *process_list = control_flow_data->process_list; LttTime birth = process->creation_time; - if(likely(process_list->current_hash_data[tfc->index] != NULL)) { - hashed_process_data = process_list->current_hash_data[tfc->index]; + if(likely(process_list->current_hash_data[ltt_tracefile_num(tfc->tf)] != NULL)) { + hashed_process_data = process_list->current_hash_data[ltt_tracefile_num(tfc->tf)]; } else { hashed_process_data = processlist_get_process_data(process_list, pid, @@ -2013,8 +1998,10 @@ int before_execmode_hook(void *hook_data, void *call_data) g_assert(pid == 0 || pid != process->ppid); ProcessInfo *process_info; /* Process not present */ + Drawing_t *drawing = control_flow_data->drawing; const gchar *name = g_quark_to_string(process->name); processlist_add(process_list, + drawing, pid, process->last_cpu_index, process->ppid, @@ -2024,11 +2011,10 @@ int before_execmode_hook(void *hook_data, void *call_data) &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); + 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->last_cpu_index] = @@ -2043,10 +2029,6 @@ int before_execmode_hook(void *hook_data, void *call_data) evtime) > 0)) { if(unlikely(hashed_process_data->x.middle_marked == FALSE)) { - processlist_get_pixels_from_data(process_list, - hashed_process_data, - &y, - &height); TimeWindow time_window = lttvwindow_get_time_window(control_flow_data->tab); @@ -2066,17 +2048,13 @@ int before_execmode_hook(void *hook_data, void *call_data) /* Draw collision indicator */ gdk_gc_set_foreground(drawing->gc, &drawing_colors[COL_WHITE]); - gdk_draw_point(drawing->pixmap, + gdk_draw_point(hashed_process_data->pixmap, drawing->gc, x, - y+(height/2)-3); + (hashed_process_data->height/2)-3); hashed_process_data->x.middle_marked = TRUE; } } else { - processlist_get_pixels_from_data(process_list, - hashed_process_data, - &y, - &height); TimeWindow time_window = lttvwindow_get_time_window(control_flow_data->tab); @@ -2103,10 +2081,10 @@ int before_execmode_hook(void *hook_data, void *call_data) if(unlikely(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, + gdk_draw_point(hashed_process_data->pixmap, drawing->gc, x, - y+(height/2)-3); + (hashed_process_data->height/2)-3); hashed_process_data->x.middle_marked = TRUE; } /* jump */ @@ -2115,15 +2093,15 @@ int before_execmode_hook(void *hook_data, void *call_data) 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.drawable = hashed_process_data->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.y.over = 1; + draw_context.drawinfo.y.middle = (hashed_process_data->height/2); + draw_context.drawinfo.y.under = hashed_process_data->height; draw_context.drawinfo.start.offset.over = 0; draw_context.drawinfo.start.offset.middle = 0; @@ -2169,8 +2147,8 @@ int after_execmode_hook(void *hook_data, void *call_data) return 0; - - EventsRequest *events_request = (EventsRequest*)hook_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; @@ -2178,14 +2156,14 @@ int after_execmode_hook(void *hook_data, void *call_data) LttvTracefileState *tfs = (LttvTracefileState *)call_data; LttEvent *e; - e = tfc->e; + e = ltt_tracefile_get_event(tfc->tf); LttTime evtime = ltt_event_time(e); /* Add process to process list (if not present) */ LttvProcessState *process; LttTime birth; - guint y = 0, height = 0, pl_height = 0; + guint pl_height = 0; HashedProcessData *hashed_process_data = NULL; ProcessList *process_list = control_flow_data->process_list; @@ -2199,8 +2177,8 @@ int after_execmode_hook(void *hook_data, void *call_data) birth = process->creation_time; - if(likely(process_list->current_hash_data[tfc->index] != NULL)) { - hashed_process_data = process_list->current_hash_data[tfc->index]; + if(likely(process_list->current_hash_data[ltt_tracefile_num(tfc->tf)] != NULL)) { + hashed_process_data = process_list->current_hash_data[ltt_tracefile_num(tfc->tf)]; } else { hashed_process_data = processlist_get_process_data(process_list, pid, @@ -2211,9 +2189,11 @@ int after_execmode_hook(void *hook_data, void *call_data) { g_assert(pid == 0 || pid != process->ppid); /* Process not present */ + Drawing_t *drawing = control_flow_data->drawing; const gchar *name = g_quark_to_string(process->name); ProcessInfo *process_info; processlist_add(process_list, + drawing, pid, process->last_cpu_index, process->ppid, @@ -2223,11 +2203,10 @@ int after_execmode_hook(void *hook_data, void *call_data) &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); + 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->last_cpu_index] = @@ -2237,12 +2216,6 @@ int after_execmode_hook(void *hook_data, void *call_data) if(unlikely(ltt_time_compare(hashed_process_data->next_good_time, evtime) <= 0)) { -#if 0 - processlist_get_pixels_from_data(process_list, - hashed_process_data, - &y, - &height); -#endif //0 TimeWindow time_window = lttvwindow_get_time_window(control_flow_data->tab); @@ -2272,7 +2245,8 @@ int after_execmode_hook(void *hook_data, void *call_data) -/* before_process_hook + +/* before_process_exit_hook * * Draw lines for process event. * @@ -2282,9 +2256,14 @@ int after_execmode_hook(void *hook_data, void *call_data) * This function adds items to be drawn in a queue for each process. * */ -int before_process_hook(void *hook_data, void *call_data) + + +int before_process_exit_hook(void *hook_data, void *call_data) { - EventsRequest *events_request = (EventsRequest*)hook_data; + return 0; //DISABLED + 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; @@ -2292,107 +2271,64 @@ int before_process_hook(void *hook_data, void *call_data) LttvTracefileState *tfs = (LttvTracefileState *)call_data; LttEvent *e; - e = tfc->e; + e = ltt_tracefile_get_event(tfc->tf); LttTime evtime = ltt_event_time(e); - 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; - - ProcessList *process_list = control_flow_data->process_list; - - g_assert(process != NULL); + /* Add process to process list (if not present) */ + LttvProcessState *process = tfs->process; + guint pid = process->pid; + LttTime birth; + guint pl_height = 0; + HashedProcessData *hashed_process_data = NULL; - birth = process->creation_time; + ProcessList *process_list = control_flow_data->process_list; + + g_assert(process != NULL); - if(likely(process_list->current_hash_data[tfc->index] != NULL)) { - hashed_process_data = process_list->current_hash_data[tfc->index]; - } else { - hashed_process_data = processlist_get_process_data(process_list, - pid, - process->last_cpu_index, - &birth, - tfc->t_context->index); - if(unlikely(hashed_process_data == NULL)) - { - 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); - } - } + birth = process->creation_time; - /* Now, the process is in the state hash and our own process hash. - * We definitely can draw the items related to the ending state. - */ - - if(likely(ltt_time_compare(hashed_process_data->next_good_time, - evtime) > 0)) + if(likely(process_list->current_hash_data[ltt_tracefile_num(tfc->tf)] != NULL)) { + hashed_process_data = process_list->current_hash_data[ltt_tracefile_num(tfc->tf)]; + } else { + hashed_process_data = processlist_get_process_data(process_list, + pid, + process->last_cpu_index, + &birth, + tfc->t_context->index); + if(unlikely(hashed_process_data == NULL)) { - if(unlikely(hashed_process_data->x.middle_marked == FALSE)) { - processlist_get_pixels_from_data(process_list, - hashed_process_data, - &y, - &height); - 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 x; - convert_time_to_pixels( - time_window, - evtime, - width, - &x); + g_assert(pid == 0 || pid != process->ppid); + /* Process not present */ + Drawing_t *drawing = control_flow_data->drawing; + const gchar *name = g_quark_to_string(process->name); + ProcessInfo *process_info; + processlist_add(process_list, + drawing, + pid, + process->last_cpu_index, + process->ppid, + &birth, + tfc->t_context->index, + name, + &pl_height, + &process_info, + &hashed_process_data); + gtk_widget_set_size_request(drawing->drawing_area, + -1, + pl_height); + gtk_widget_queue_draw(drawing->drawing_area); + } + } - /* 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 { - processlist_get_pixels_from_data(process_list, - hashed_process_data, - &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. + */ + + if(likely(ltt_time_compare(hashed_process_data->next_good_time, + evtime) > 0)) + { + if(unlikely(hashed_process_data->x.middle_marked == FALSE)) { TimeWindow time_window = lttvwindow_get_time_window(control_flow_data->tab); @@ -2404,76 +2340,886 @@ int before_process_hook(void *hook_data, void *call_data) Drawing_t *drawing = control_flow_data->drawing; guint width = drawing->width; guint x; - convert_time_to_pixels( - time_window, - evtime, - width, - &x); - + time_window, + evtime, + width, + &x); - /* Jump over draw if we are at the same x position */ - if(unlikely(x == hashed_process_data->x.middle && - hashed_process_data->x.middle_used)) - { - if(unlikely(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 collision indicator */ + gdk_gc_set_foreground(drawing->gc, &drawing_colors[COL_WHITE]); + gdk_draw_point(hashed_process_data->pixmap, + drawing->gc, + x, + (hashed_process_data->height/2)-3); + hashed_process_data->x.middle_marked = TRUE; + } + } else { + TimeWindow time_window = + lttvwindow_get_time_window(control_flow_data->tab); - /* 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; +#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 x; - draw_context.drawinfo.y.over = y+1; - draw_context.drawinfo.y.middle = y+(height/2); - draw_context.drawinfo.y.under = y+height; + convert_time_to_pixels( + time_window, + evtime, + width, + &x); - 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); + /* Jump over draw if we are at the same x position */ + if(unlikely(x == hashed_process_data->x.middle && + hashed_process_data->x.middle_used)) + { + if(unlikely(hashed_process_data->x.middle_marked == FALSE)) { + /* Draw collision indicator */ + gdk_gc_set_foreground(drawing->gc, &drawing_colors[COL_WHITE]); + gdk_draw_point(hashed_process_data->pixmap, + drawing->gc, + x, + (hashed_process_data->height/2)-3); + hashed_process_data->x.middle_marked = TRUE; + } + /* jump */ + } else { + DrawContext 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; + /* Now create the drawing context that will be used to draw + * items related to the last state. */ + draw_context.drawable = hashed_process_data->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; - /* Calculate the next good time */ - convert_pixels_to_time(width, x+1, time_window, - &hashed_process_data->next_good_time); - } - } + draw_context.drawinfo.y.over = 1; + draw_context.drawinfo.y.middle = (hashed_process_data->height/2); + draw_context.drawinfo.y.under = hashed_process_data->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; + + /* Calculate the next good time */ + convert_pixels_to_time(width, x+1, time_window, + &hashed_process_data->next_good_time); + } + } + + return 0; + +} + + + +/* before_process_release_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_release_hook(void *hook_data, void *call_data) +{ + return 0; //DISABLED + 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; + + LttEvent *e; + e = ltt_tracefile_get_event(tfc->tf); + + LttTime evtime = ltt_event_time(e); + + + guint pid; + { + pid = ltt_event_get_long_unsigned(e, thf->f1); + } + + /* Add process to process list (if not present) */ + /* Don't care about the process if it's not in the state hash already : + * that means a process that has never done anything in the trace and + * unknown suddently gets destroyed : no state meaningful to show. */ + LttvProcessState *process = lttv_state_find_process(tfs, pid); + + if(process != NULL) { + LttTime birth; + guint pl_height = 0; + HashedProcessData *hashed_process_data = NULL; + + ProcessList *process_list = control_flow_data->process_list; + + birth = process->creation_time; + + /* Cannot use current process : this event happens on another process, + * action done by the parent. */ + hashed_process_data = processlist_get_process_data(process_list, + pid, + process->last_cpu_index, + &birth, + tfc->t_context->index); + if(unlikely(hashed_process_data == NULL)) + { + g_assert(pid == 0 || pid != process->ppid); + /* Process not present */ + Drawing_t *drawing = control_flow_data->drawing; + const gchar *name = g_quark_to_string(process->name); + ProcessInfo *process_info; + processlist_add(process_list, + drawing, + pid, + process->last_cpu_index, + process->ppid, + &birth, + tfc->t_context->index, + name, + &pl_height, + &process_info, + &hashed_process_data); + gtk_widget_set_size_request(drawing->drawing_area, + -1, + pl_height); + gtk_widget_queue_draw(drawing->drawing_area); + } + + /* Now, the process is in the state hash and our own process hash. + * We definitely can draw the items related to the ending state. + */ + + if(likely(ltt_time_compare(hashed_process_data->next_good_time, + evtime) > 0)) + { + if(unlikely(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 + Drawing_t *drawing = control_flow_data->drawing; + guint width = drawing->width; + 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(hashed_process_data->pixmap, + drawing->gc, + x, + (hashed_process_data->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 + Drawing_t *drawing = control_flow_data->drawing; + guint width = drawing->width; + guint x; + + convert_time_to_pixels( + time_window, + evtime, + width, + &x); + + + /* Jump over draw if we are at the same x position */ + if(unlikely(x == hashed_process_data->x.middle && + hashed_process_data->x.middle_used)) + { + if(unlikely(hashed_process_data->x.middle_marked == FALSE)) { + /* Draw collision indicator */ + gdk_gc_set_foreground(drawing->gc, &drawing_colors[COL_WHITE]); + gdk_draw_point(hashed_process_data->pixmap, + drawing->gc, + x, + (hashed_process_data->height/2)-3); + hashed_process_data->x.middle_marked = TRUE; + } + /* 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 = hashed_process_data->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 = 1; + draw_context.drawinfo.y.middle = (hashed_process_data->height/2); + draw_context.drawinfo.y.under = hashed_process_data->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; + + /* Calculate the next good time */ + convert_pixels_to_time(width, x+1, time_window, + &hashed_process_data->next_good_time); + } + } + } + + return 0; +} + + + + + + + + +#if 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) +{ + 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; + + LttEvent *e; + e = ltt_tracefile_get_event(tfc->tf); + + LttTime evtime = ltt_event_time(e); + + 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 pl_height = 0; + HashedProcessData *hashed_process_data = NULL; + + ProcessList *process_list = control_flow_data->process_list; + + g_assert(process != NULL); + + birth = process->creation_time; + + if(likely(process_list->current_hash_data[tfc->index] != NULL)) { + hashed_process_data = process_list->current_hash_data[tfc->index]; + } else { + hashed_process_data = processlist_get_process_data(process_list, + pid, + process->last_cpu_index, + &birth, + tfc->t_context->index); + if(unlikely(hashed_process_data == NULL)) + { + g_assert(pid == 0 || pid != process->ppid); + /* Process not present */ + Drawing_t *drawing = control_flow_data->drawing; + const gchar *name = g_quark_to_string(process->name); + ProcessInfo *process_info; + processlist_add(process_list, + drawing, + pid, + process->last_cpu_index, + process->ppid, + &birth, + tfc->t_context->index, + name, + &pl_height, + &process_info, + &hashed_process_data); + gtk_widget_set_size_request(drawing->drawing_area, + -1, + pl_height); + gtk_widget_queue_draw(drawing->drawing_area); + } + } + + /* Now, the process is in the state hash and our own process hash. + * We definitely can draw the items related to the ending state. + */ + + if(likely(ltt_time_compare(hashed_process_data->next_good_time, + evtime) > 0)) + { + if(unlikely(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 + Drawing_t *drawing = control_flow_data->drawing; + guint width = drawing->width; + 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(hashed_process_data->pixmap, + drawing->gc, + x, + (hashed_process_data->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 + Drawing_t *drawing = control_flow_data->drawing; + guint width = drawing->width; + guint x; + + convert_time_to_pixels( + time_window, + evtime, + width, + &x); + + + /* Jump over draw if we are at the same x position */ + if(unlikely(x == hashed_process_data->x.middle && + hashed_process_data->x.middle_used)) + { + if(unlikely(hashed_process_data->x.middle_marked == FALSE)) { + /* Draw collision indicator */ + gdk_gc_set_foreground(drawing->gc, &drawing_colors[COL_WHITE]); + gdk_draw_point(hashed_process_data->pixmap, + drawing->gc, + x, + (hashed_process_data->height/2)-3); + hashed_process_data->x.middle_marked = TRUE; + } + /* 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 = hashed_process_data->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 = 1; + draw_context.drawinfo.y.middle = (hashed_process_data->height/2); + draw_context.drawinfo.y.under = hashed_process_data->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; + + /* Calculate the next good time */ + convert_pixels_to_time(width, x+1, time_window, + &hashed_process_data->next_good_time); + } + } + + } else if(sub_id == 7) /* release */ { + + guint pid; + { + LttField *f = ltt_event_field(e); + LttField *element; + element = ltt_field_member(f,1); + pid = ltt_event_get_long_unsigned(e,element); + } + + /* Add process to process list (if not present) */ + /* Don't care about the process if it's not in the state hash already : + * that means a process that has never done anything in the trace and + * unknown suddently gets destroyed : no state meaningful to show. */ + LttvProcessState *process = lttv_state_find_process(tfs, pid); + + if(process != NULL) { + LttTime birth; + guint pl_height = 0; + HashedProcessData *hashed_process_data = NULL; + + ProcessList *process_list = control_flow_data->process_list; + + birth = process->creation_time; + + /* Cannot use current process : this event happens on another process, + * action done by the parent. */ + hashed_process_data = processlist_get_process_data(process_list, + pid, + process->last_cpu_index, + &birth, + tfc->t_context->index); + if(unlikely(hashed_process_data == NULL)) + { + g_assert(pid == 0 || pid != process->ppid); + /* Process not present */ + Drawing_t *drawing = control_flow_data->drawing; + const gchar *name = g_quark_to_string(process->name); + ProcessInfo *process_info; + processlist_add(process_list, + drawing, + pid, + process->last_cpu_index, + process->ppid, + &birth, + tfc->t_context->index, + name, + &pl_height, + &process_info, + &hashed_process_data); + gtk_widget_set_size_request(drawing->drawing_area, + -1, + pl_height); + gtk_widget_queue_draw(drawing->drawing_area); + } + + /* Now, the process is in the state hash and our own process hash. + * We definitely can draw the items related to the ending state. + */ + + if(likely(ltt_time_compare(hashed_process_data->next_good_time, + evtime) > 0)) + { + if(unlikely(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 + Drawing_t *drawing = control_flow_data->drawing; + guint width = drawing->width; + 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(hashed_process_data->pixmap, + drawing->gc, + x, + (hashed_process_data->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 + Drawing_t *drawing = control_flow_data->drawing; + guint width = drawing->width; + guint x; + + convert_time_to_pixels( + time_window, + evtime, + width, + &x); + + + /* Jump over draw if we are at the same x position */ + if(unlikely(x == hashed_process_data->x.middle && + hashed_process_data->x.middle_used)) + { + if(unlikely(hashed_process_data->x.middle_marked == FALSE)) { + /* Draw collision indicator */ + gdk_gc_set_foreground(drawing->gc, &drawing_colors[COL_WHITE]); + gdk_draw_point(hashed_process_data->pixmap, + drawing->gc, + x, + (hashed_process_data->height/2)-3); + hashed_process_data->x.middle_marked = TRUE; + } + /* 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 = hashed_process_data->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 = 1; + draw_context.drawinfo.y.middle = (hashed_process_data->height/2); + draw_context.drawinfo.y.under = hashed_process_data->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; + + /* Calculate the next good time */ + convert_pixels_to_time(width, x+1, time_window, + &hashed_process_data->next_good_time); + } + } + } + + } return 0; } +#endif //0 + + + +/* after_process_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_process_fork_hook(void *hook_data, void *call_data) +{ + return 0; //DISABLED + 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; + + LttEvent *e; + e = ltt_tracefile_get_event(tfc->tf); + + LttTime evtime = ltt_event_time(e); + + guint child_pid; + { + child_pid = ltt_event_get_long_unsigned(e, thf->f2); + } + + /* Add process to process list (if not present) */ + LttvProcessState *process_child; + LttTime birth; + guint pl_height = 0; + HashedProcessData *hashed_process_data_child = NULL; + + ProcessList *process_list = control_flow_data->process_list; + + /* 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; + + /* Cannot use current process, because this action is done by the parent + * on its child. */ + hashed_process_data_child = processlist_get_process_data(process_list, + child_pid, + process_child->last_cpu_index, + &birth, + tfc->t_context->index); + if(likely(hashed_process_data_child == NULL)) + { + g_assert(child_pid == 0 || child_pid != process_child->ppid); + /* Process not present */ + Drawing_t *drawing = control_flow_data->drawing; + const gchar *name = g_quark_to_string(process_child->name); + ProcessInfo *process_info; + processlist_add(process_list, + drawing, + child_pid, + process_child->last_cpu_index, + process_child->ppid, + &birth, + tfc->t_context->index, + name, + &pl_height, + &process_info, + &hashed_process_data_child); + gtk_widget_set_size_request(drawing->drawing_area, + -1, + pl_height); + gtk_widget_queue_draw(drawing->drawing_area); + } + + + if(likely(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 + 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(likely(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(likely(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(likely(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; + } + } + return 0; +} + + + +/* after_process_exit_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_exit_hook(void *hook_data, void *call_data) +{ + return 0; //DISABLED + 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; + + 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 = tfs->process; + guint pid = process->pid; + LttTime birth; + guint pl_height = 0; + HashedProcessData *hashed_process_data = NULL; + + 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; + + if(likely(process_list->current_hash_data[ltt_tracefile_num(tfc->tf)] != NULL) ){ + hashed_process_data = process_list->current_hash_data[ltt_tracefile_num(tfc->tf)]; + } else { + hashed_process_data = processlist_get_process_data(process_list, + pid, + process->last_cpu_index, + &birth, + tfc->t_context->index); + if(unlikely(hashed_process_data == NULL)) + { + g_assert(pid == 0 || pid != process->ppid); + /* Process not present */ + Drawing_t *drawing = control_flow_data->drawing; + const gchar *name = g_quark_to_string(process->name); + ProcessInfo *process_info; + processlist_add(process_list, + drawing, + pid, + process->last_cpu_index, + process->ppid, + &birth, + tfc->t_context->index, + name, + &pl_height, + &process_info, + &hashed_process_data); + 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->last_cpu_index] = + hashed_process_data; + } + + if(unlikely(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 + 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(unlikely(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; +} +#if 0 /* after_process_hook * @@ -2488,7 +3234,8 @@ int before_process_hook(void *hook_data, void *call_data) */ int after_process_hook(void *hook_data, void *call_data) { - EventsRequest *events_request = (EventsRequest*)hook_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; @@ -2496,7 +3243,7 @@ int after_process_hook(void *hook_data, void *call_data) LttvTracefileState *tfs = (LttvTracefileState *)call_data; LttEvent *e; - e = tfc->e; + e = ltt_tracefile_get_event(tfc->tf); LttTime evtime = ltt_event_time(e); @@ -2517,7 +3264,7 @@ int after_process_hook(void *hook_data, void *call_data) /* Add process to process list (if not present) */ LttvProcessState *process_child; LttTime birth; - guint y_child = 0, height = 0, pl_height = 0; + guint pl_height = 0; HashedProcessData *hashed_process_data_child = NULL; ProcessList *process_list = control_flow_data->process_list; @@ -2529,6 +3276,8 @@ int after_process_hook(void *hook_data, void *call_data) birth = process_child->creation_time; + /* Cannot use current process, because this action is done by the parent + * on its child. */ hashed_process_data_child = processlist_get_process_data(process_list, child_pid, process_child->last_cpu_index, @@ -2538,9 +3287,11 @@ int after_process_hook(void *hook_data, void *call_data) { g_assert(child_pid == 0 || child_pid != process_child->ppid); /* Process not present */ + Drawing_t *drawing = control_flow_data->drawing; const gchar *name = g_quark_to_string(process_child->name); ProcessInfo *process_info; processlist_add(process_list, + drawing, child_pid, process_child->last_cpu_index, process_child->ppid, @@ -2550,23 +3301,16 @@ int after_process_hook(void *hook_data, void *call_data) &pl_height, &process_info, &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); + gtk_widget_set_size_request(drawing->drawing_area, + -1, + pl_height); + gtk_widget_queue_draw(drawing->drawing_area); } if(likely(ltt_time_compare(hashed_process_data_child->next_good_time, evtime) <= 0)) { -#if 0 - processlist_get_pixels_from_data(process_list, - hashed_process_data_child, - &y_child, - &height); -#endif //0 TimeWindow time_window = lttvwindow_get_time_window(control_flow_data->tab); @@ -2607,7 +3351,7 @@ int after_process_hook(void *hook_data, void *call_data) LttvProcessState *process = tfs->process; guint pid = process->pid; LttTime birth; - guint y = 0, height = 0, pl_height = 0; + guint pl_height = 0; HashedProcessData *hashed_process_data = NULL; ProcessList *process_list = control_flow_data->process_list; @@ -2617,8 +3361,8 @@ int after_process_hook(void *hook_data, void *call_data) birth = process->creation_time; - if(likely(process_list->current_hash_data[tfc->index] != NULL) ){ - hashed_process_data = process_list->current_hash_data[tfc->index]; + if(likely(process_list->current_hash_data[ltt_tracefile_num(tfc->tf)] != NULL) ){ + hashed_process_data = process_list->current_hash_data[ltt_tracefile_num(tfc->tf)]; } else { hashed_process_data = processlist_get_process_data(process_list, pid, @@ -2629,9 +3373,11 @@ int after_process_hook(void *hook_data, void *call_data) { g_assert(pid == 0 || pid != process->ppid); /* Process not present */ + Drawing_t *drawing = control_flow_data->drawing; const gchar *name = g_quark_to_string(process->name); ProcessInfo *process_info; processlist_add(process_list, + drawing, pid, process->last_cpu_index, process->ppid, @@ -2641,11 +3387,10 @@ int after_process_hook(void *hook_data, void *call_data) &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); + gtk_widget_set_size_request(drawing->drawing_area, + -1, + pl_height); + gtk_widget_queue_draw(drawing->drawing_area); } /* Set the current process */ @@ -2656,12 +3401,6 @@ int after_process_hook(void *hook_data, void *call_data) if(unlikely(ltt_time_compare(hashed_process_data->next_good_time, evtime) <= 0)) { -#if 0 - processlist_get_pixels_from_data(process_list, - hashed_process_data, - &y, - &height); -#endif //0 TimeWindow time_window = lttvwindow_get_time_window(control_flow_data->tab); @@ -2689,12 +3428,13 @@ int after_process_hook(void *hook_data, void *call_data) return 0; } - +#endif //0 gint update_time_window_hook(void *hook_data, void *call_data) { ControlFlowData *control_flow_data = (ControlFlowData*) hook_data; Drawing_t *drawing = control_flow_data->drawing; + ProcessList *process_list = control_flow_data->process_list; const TimeWindowNotifyData *time_window_nofify_data = ((const TimeWindowNotifyData *)call_data); @@ -2756,13 +3496,14 @@ gint update_time_window_hook(void *hook_data, void *call_data) &x); /* Copy old data to new location */ - gdk_draw_drawable (control_flow_data->drawing->pixmap, - control_flow_data->drawing->drawing_area->style->black_gc, - control_flow_data->drawing->pixmap, - x, 0, - 0, 0, - control_flow_data->drawing->width-x+SAFETY, -1); - + copy_pixmap_region(process_list, + NULL, + control_flow_data->drawing->drawing_area->style->black_gc, + NULL, + x, 0, + 0, 0, + control_flow_data->drawing->width-x+SAFETY, -1); + if(drawing->damage_begin == drawing->damage_end) drawing->damage_begin = control_flow_data->drawing->width-x; else @@ -2771,22 +3512,20 @@ gint update_time_window_hook(void *hook_data, void *call_data) drawing->damage_end = control_flow_data->drawing->width; /* Clear the data request background, but not SAFETY */ - gdk_draw_rectangle (control_flow_data->drawing->pixmap, - //control_flow_data->drawing->drawing_area->style->black_gc, + rectangle_pixmap(process_list, control_flow_data->drawing->drawing_area->style->black_gc, TRUE, drawing->damage_begin+SAFETY, 0, drawing->damage_end - drawing->damage_begin, // do not overlap - control_flow_data->drawing->height); - - gtk_widget_queue_draw_area (drawing->drawing_area, - 0,0, - control_flow_data->drawing->width, - control_flow_data->drawing->height); + -1); + gtk_widget_queue_draw(drawing->drawing_area); + //gtk_widget_queue_draw_area (drawing->drawing_area, + // 0,0, + // control_flow_data->drawing->width, + // control_flow_data->drawing->height); /* Get new data for the rest. */ drawing_data_request(control_flow_data->drawing, - &control_flow_data->drawing->pixmap, drawing->damage_begin, 0, drawing->damage_end - drawing->damage_begin, control_flow_data->drawing->height); @@ -2807,11 +3546,11 @@ gint update_time_window_hook(void *hook_data, void *call_data) width, &x); - /* Copy old data to new location */ - gdk_draw_drawable (control_flow_data->drawing->pixmap, + copy_pixmap_region (process_list, + NULL, control_flow_data->drawing->drawing_area->style->black_gc, - control_flow_data->drawing->pixmap, + NULL, 0, 0, x, 0, -1, -1); @@ -2824,22 +3563,22 @@ gint update_time_window_hook(void *hook_data, void *call_data) drawing->damage_begin = 0; - gdk_draw_rectangle (control_flow_data->drawing->pixmap, + rectangle_pixmap (process_list, control_flow_data->drawing->drawing_area->style->black_gc, TRUE, drawing->damage_begin, 0, drawing->damage_end - drawing->damage_begin, // do not overlap - control_flow_data->drawing->height); + -1); - gtk_widget_queue_draw_area (drawing->drawing_area, - 0,0, - control_flow_data->drawing->width, - control_flow_data->drawing->height); + gtk_widget_queue_draw(drawing->drawing_area); + //gtk_widget_queue_draw_area (drawing->drawing_area, + // 0,0, + // control_flow_data->drawing->width, + // control_flow_data->drawing->height); /* Get new data for the rest. */ drawing_data_request(control_flow_data->drawing, - &control_flow_data->drawing->pixmap, drawing->damage_begin, 0, drawing->damage_end - drawing->damage_begin, control_flow_data->drawing->height); @@ -2853,23 +3592,23 @@ gint update_time_window_hook(void *hook_data, void *call_data) /* Cannot reuse any part of the screen : far jump */ - gdk_draw_rectangle (control_flow_data->drawing->pixmap, + rectangle_pixmap (process_list, control_flow_data->drawing->drawing_area->style->black_gc, TRUE, 0, 0, control_flow_data->drawing->width+SAFETY, // do not overlap - control_flow_data->drawing->height); + -1); - gtk_widget_queue_draw_area (drawing->drawing_area, - 0,0, - control_flow_data->drawing->width, - control_flow_data->drawing->height); + //gtk_widget_queue_draw_area (drawing->drawing_area, + // 0,0, + // control_flow_data->drawing->width, + // control_flow_data->drawing->height); + gtk_widget_queue_draw(drawing->drawing_area); drawing->damage_begin = 0; drawing->damage_end = control_flow_data->drawing->width; drawing_data_request(control_flow_data->drawing, - &control_flow_data->drawing->pixmap, 0, 0, control_flow_data->drawing->width, control_flow_data->drawing->height); @@ -2881,23 +3620,23 @@ gint update_time_window_hook(void *hook_data, void *call_data) /* Different scale (zoom) */ g_info("zoom"); - gdk_draw_rectangle (control_flow_data->drawing->pixmap, + rectangle_pixmap (process_list, control_flow_data->drawing->drawing_area->style->black_gc, TRUE, 0, 0, control_flow_data->drawing->width+SAFETY, // do not overlap - control_flow_data->drawing->height); + -1); - gtk_widget_queue_draw_area (drawing->drawing_area, - 0,0, - control_flow_data->drawing->width, - control_flow_data->drawing->height); + //gtk_widget_queue_draw_area (drawing->drawing_area, + // 0,0, + // control_flow_data->drawing->width, + // control_flow_data->drawing->height); + gtk_widget_queue_draw(drawing->drawing_area); drawing->damage_begin = 0; drawing->damage_end = control_flow_data->drawing->width; drawing_data_request(control_flow_data->drawing, - &control_flow_data->drawing->pixmap, 0, 0, control_flow_data->drawing->width, control_flow_data->drawing->height); @@ -2916,6 +3655,9 @@ gint traceset_notify(void *hook_data, void *call_data) drawing_clear(control_flow_data->drawing); processlist_clear(control_flow_data->process_list); + gtk_widget_set_size_request( + control_flow_data->drawing->drawing_area, + -1, processlist_get_height(control_flow_data->process_list)); redraw_notify(control_flow_data, NULL); request_background_data(control_flow_data); @@ -2935,30 +3677,32 @@ gint redraw_notify(void *hook_data, void *call_data) /* 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, + gtk_widget_set_size_request( + control_flow_data->drawing->drawing_area, + -1, processlist_get_height(control_flow_data->process_list)); + // Clear the images + rectangle_pixmap (control_flow_data->process_list, widget->style->black_gc, TRUE, 0, 0, - drawing->width+SAFETY, - drawing->height); + drawing->alloc_width, + -1); + gtk_widget_queue_draw(drawing->drawing_area); if(drawing->damage_begin < drawing->damage_end) { drawing_data_request(drawing, - &drawing->pixmap, drawing->damage_begin, 0, drawing->damage_end-drawing->damage_begin, drawing->height); } - gtk_widget_queue_draw_area(drawing->drawing_area, - 0,0, - drawing->width, - drawing->height); + //gtk_widget_queue_draw_area(drawing->drawing_area, + // 0,0, + // drawing->width, + // drawing->height); return FALSE; } @@ -2974,7 +3718,6 @@ gint continue_notify(void *hook_data, void *call_data) if(drawing->damage_begin < drawing->damage_end) { drawing_data_request(drawing, - &drawing->pixmap, drawing->damage_begin, 0, drawing->damage_end-drawing->damage_begin, @@ -3026,12 +3769,12 @@ gint update_current_time_hook(void *hook_data, void *call_data) * at one end of the trace. */ - if(ltt_time_compare(current_time, time_begin) == -1) + if(ltt_time_compare(current_time, time_begin) < 0) { TimeWindow new_time_window; if(ltt_time_compare(current_time, - ltt_time_add(trace_start,half_width)) == -1) + ltt_time_add(trace_start,half_width)) < 0) time_begin = trace_start; else time_begin = ltt_time_sub(current_time,half_width); @@ -3043,11 +3786,11 @@ gint update_current_time_hook(void *hook_data, void *call_data) lttvwindow_report_time_window(control_flow_data->tab, new_time_window); } - else if(ltt_time_compare(current_time, time_end) == 1) + else if(ltt_time_compare(current_time, time_end) > 0) { TimeWindow new_time_window; - if(ltt_time_compare(current_time, ltt_time_sub(trace_end, half_width)) == 1) + if(ltt_time_compare(current_time, ltt_time_sub(trace_end, half_width)) > 0) time_begin = ltt_time_sub(trace_end,width); else time_begin = ltt_time_sub(current_time,half_width); @@ -3060,11 +3803,8 @@ gint update_current_time_hook(void *hook_data, void *call_data) lttvwindow_report_time_window(control_flow_data->tab, new_time_window); } - //gtk_widget_queue_draw(control_flow_data->drawing->drawing_area); - gtk_widget_queue_draw_area(drawing->drawing_area, - 0,0, - drawing->width, - drawing->height); + gtk_widget_queue_draw(control_flow_data->drawing->drawing_area); + return 0; } @@ -3101,11 +3841,26 @@ void draw_closure(gpointer key, gpointer value, gpointer user_data) #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 = - (LttvTracefileState*)tsc->traces[process_info->trace_num]->tracefiles[0]; + LttvTraceContext *tc = tsc->traces[process_info->trace_num]; + + //FIXME : optimize data structures. + LttvTracefileState *tfs; + LttvTracefileContext *tfc; + guint i; + for(i=0;itracefiles->len;i++) { + tfc = g_array_index(tc->tracefiles, LttvTracefileContext*, i); + if(ltt_tracefile_name(tfc->tf) == LTT_NAME_CPU + && ltt_tracefile_num(tfc->tf) == process_info->cpu) + break; + } + g_assert(itracefiles->len); + tfs = LTTV_TRACEFILE_STATE(tfc); + + // LttvTracefileState *tfs = + // (LttvTracefileState*)tsc->traces[process_info->trace_num]-> + // tracefiles[process_info->cpu]; + LttvProcessState *process; process = lttv_state_find_process(tfs, process_info->pid); @@ -3114,7 +3869,6 @@ void draw_closure(gpointer key, gpointer value, gpointer user_data) /* Only draw for processes that are currently in the trace states */ - guint y = 0, height = 0; ProcessList *process_list = control_flow_data->process_list; #ifdef EXTRA_CHECK /* Should be alike when background info is ready */ @@ -3122,11 +3876,6 @@ void draw_closure(gpointer key, gpointer value, gpointer user_data) g_assert(ltt_time_compare(process->creation_time, process_info->birth) == 0); #endif //EXTRA_CHECK - /* process HAS to be present */ - processlist_get_pixels_from_data(process_list, - hashed_process_data, - &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. @@ -3152,14 +3901,14 @@ void draw_closure(gpointer key, gpointer value, gpointer user_data) /* Now create the drawing context that will be used to draw * items related to the last state. */ - draw_context.drawable = drawing->pixmap; + draw_context.drawable = hashed_process_data->pixmap; draw_context.gc = drawing->gc; draw_context.pango_layout = drawing->pango_layout; 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.y.over = 1; + draw_context.drawinfo.y.middle = (hashed_process_data->height/2); + draw_context.drawinfo.y.under = hashed_process_data->height; draw_context.drawinfo.start.offset.over = 0; draw_context.drawinfo.start.offset.middle = 0; @@ -3223,7 +3972,14 @@ int before_chunk(void *hook_data, void *call_data) { EventsRequest *events_request = (EventsRequest*)hook_data; LttvTracesetState *tss = (LttvTracesetState*)call_data; - + ControlFlowData *cfd = (ControlFlowData*)events_request->viewer_data; +#if 0 + /* Desactivate sort */ + gtk_tree_sortable_set_sort_column_id( + GTK_TREE_SORTABLE(cfd->process_list->list_store), + TRACE_COLUMN, + GTK_SORT_ASCENDING); +#endif //0 drawing_chunk_begin(events_request, tss); return 0; @@ -3233,7 +3989,7 @@ int before_request(void *hook_data, void *call_data) { EventsRequest *events_request = (EventsRequest*)hook_data; LttvTracesetState *tss = (LttvTracesetState*)call_data; - + drawing_data_request_begin(events_request, tss); return 0; @@ -3276,6 +4032,7 @@ int after_request(void *hook_data, void *call_data) /* Draw last items */ g_hash_table_foreach(process_list->process_hash, draw_closure, (void*)&closure_data); + /* Request expose */ drawing_request_expose(events_request, tss, end_time); @@ -3323,8 +4080,18 @@ int after_chunk(void *hook_data, void *call_data) /* Draw last items */ g_hash_table_foreach(process_list->process_hash, draw_closure, (void*)&closure_data); - - /* Request expose */ +#if 0 + /* Reactivate sort */ + gtk_tree_sortable_set_sort_column_id( + GTK_TREE_SORTABLE(control_flow_data->process_list->list_store), + GTK_TREE_SORTABLE_DEFAULT_SORT_COLUMN_ID, + GTK_SORT_ASCENDING); + + update_index_to_pixmap(control_flow_data->process_list); + /* Request a full expose : drawing scrambled */ + gtk_widget_queue_draw(control_flow_data->drawing->drawing_area); +#endif //0 + /* Request expose (updates damages zone also) */ drawing_request_expose(events_request, tss, end_time); return 0;