From dbd243b1b5f764129ae8bcf95432df750bec4a8b Mon Sep 17 00:00:00 2001 From: compudj Date: Thu, 12 Aug 2004 04:15:08 +0000 Subject: [PATCH] correct bug : need EXIT and ZOMBIE states : one for exit event, the other for schedule out git-svn-id: http://ltt.polymtl.ca/svn@707 04897980-b3bd-0310-b5e0-8ef037075253 --- ltt/branches/poly/lttv/lttv/state.c | 9 +- ltt/branches/poly/lttv/lttv/state.h | 1 + .../poly/lttv/modules/gui/controlflow/cfv.c | 10 +- .../lttv/modules/gui/controlflow/drawing.c | 31 +- .../lttv/modules/gui/controlflow/drawing.h | 12 + .../lttv/modules/gui/controlflow/eventhooks.c | 401 ++++++++++++++---- .../lttv/modules/gui/controlflow/eventhooks.h | 3 +- 7 files changed, 368 insertions(+), 99 deletions(-) diff --git a/ltt/branches/poly/lttv/lttv/state.c b/ltt/branches/poly/lttv/lttv/state.c index e9624740..20d4184a 100644 --- a/ltt/branches/poly/lttv/lttv/state.c +++ b/ltt/branches/poly/lttv/lttv/state.c @@ -41,6 +41,7 @@ LttvProcessStatus LTTV_STATE_UNNAMED, LTTV_STATE_WAIT_FORK, LTTV_STATE_WAIT_CPU, + LTTV_STATE_EXIT, LTTV_STATE_ZOMBIE, LTTV_STATE_WAIT, LTTV_STATE_RUN; @@ -969,7 +970,9 @@ static gboolean schedchange(void *hook_data, void *call_data) g_assert(s->process->pid == 0); } - if(s->process->state->s != LTTV_STATE_ZOMBIE) { + if(s->process->state->s == LTTV_STATE_EXIT) { + s->process->state->s = LTTV_STATE_ZOMBIE; + } else { if(state_out == 0) s->process->state->s = LTTV_STATE_WAIT_CPU; else s->process->state->s = LTTV_STATE_WAIT; } /* FIXME : we do not remove process here, because the kernel @@ -1008,6 +1011,7 @@ static gboolean process_fork(LttvTraceHook *trace_hook, LttvTracefileState *s) */ exit_process(s, zombie_process); } + g_assert(s->process->pid != child_pid); lttv_state_create_process(s, s->process, child_pid); return FALSE; @@ -1017,7 +1021,7 @@ static gboolean process_fork(LttvTraceHook *trace_hook, LttvTracefileState *s) static gboolean process_exit(LttvTraceHook *trace_hook, LttvTracefileState *s) { if(s->process != NULL) { - s->process->state->s = LTTV_STATE_ZOMBIE; + s->process->state->s = LTTV_STATE_EXIT; } return FALSE; } @@ -1571,6 +1575,7 @@ static void module_init() LTTV_STATE_SUBMODE_UNKNOWN = g_quark_from_string("unknown submode"); LTTV_STATE_SUBMODE_NONE = g_quark_from_string("(no submode)"); LTTV_STATE_WAIT_CPU = g_quark_from_string("wait for cpu"); + LTTV_STATE_EXIT = g_quark_from_string("exiting"); LTTV_STATE_ZOMBIE = g_quark_from_string("zombie"); LTTV_STATE_WAIT = g_quark_from_string("wait for I/O"); LTTV_STATE_RUN = g_quark_from_string("running"); diff --git a/ltt/branches/poly/lttv/lttv/state.h b/ltt/branches/poly/lttv/lttv/state.h index 8c5a1eb0..3bae70b8 100644 --- a/ltt/branches/poly/lttv/lttv/state.h +++ b/ltt/branches/poly/lttv/lttv/state.h @@ -125,6 +125,7 @@ extern LttvProcessStatus LTTV_STATE_UNNAMED, LTTV_STATE_WAIT_FORK, LTTV_STATE_WAIT_CPU, + LTTV_STATE_EXIT, LTTV_STATE_ZOMBIE, LTTV_STATE_WAIT, LTTV_STATE_RUN; diff --git a/ltt/branches/poly/lttv/modules/gui/controlflow/cfv.c b/ltt/branches/poly/lttv/modules/gui/controlflow/cfv.c index ba15e15c..fe0878be 100644 --- a/ltt/branches/poly/lttv/modules/gui/controlflow/cfv.c +++ b/ltt/branches/poly/lttv/modules/gui/controlflow/cfv.c @@ -97,8 +97,14 @@ guicontrolflow(void) "size-allocate", G_CALLBACK(header_size_allocate), (gpointer)control_flow_data->drawing); - - +#if 0 /* not ready */ + g_signal_connect ( + // G_OBJECT(control_flow_data->process_list->process_list_widget), + G_OBJECT(control_flow_data->process_list->list_store), + "row-changed", + G_CALLBACK (tree_row_activated), + (gpointer)control_flow_data); +#endif //0 control_flow_data->h_paned = gtk_hpaned_new(); control_flow_data->box = gtk_event_box_new(); diff --git a/ltt/branches/poly/lttv/modules/gui/controlflow/drawing.c b/ltt/branches/poly/lttv/modules/gui/controlflow/drawing.c index ac278e97..e84cdf5c 100644 --- a/ltt/branches/poly/lttv/modules/gui/controlflow/drawing.c +++ b/ltt/branches/poly/lttv/modules/gui/controlflow/drawing.c @@ -40,6 +40,7 @@ GdkColor drawing_colors[NUM_COLORS] = { 0, 0xFFFF, 0xFFFF, 0xFFFF }, /* COL_WHITE */ { 0, 0x0FFF, 0xFFFF, 0xFFFF }, /* COL_WAIT_FORK : pale blue */ { 0, 0xFFFF, 0xFFFF, 0x0000 }, /* COL_WAIT_CPU : yellow */ + { 0, 0xFFFF, 0xA000, 0xFCFF }, /* COL_EXIT : pale magenta */ { 0, 0xFFFF, 0x0000, 0xFFFF }, /* COL_ZOMBIE : purple */ { 0, 0xFFFF, 0x0000, 0x0000 }, /* COL_WAIT : red */ { 0, 0x0000, 0xFFFF, 0x0000 }, /* COL_RUN : green */ @@ -166,8 +167,12 @@ void drawing_data_request(Drawing_t *drawing, after_execmode_hook, events_request, LTTV_PRIO_STATE+5); - lttv_hooks_add(event, - after_fork_hook, + lttv_hooks_add(event, + before_process_hook, + events_request, + LTTV_PRIO_STATE-5); + lttv_hooks_add(event, + after_process_hook, events_request, LTTV_PRIO_STATE+5); @@ -479,6 +484,27 @@ after_expose_event( GtkWidget *widget, GdkEventExpose *event, gpointer user_data } +void +tree_row_activated(GtkTreeModel *treemodel, + GtkTreePath *arg1, + GtkTreeViewColumn *arg2, + gpointer user_data) +{ + ControlFlowData *cfd = (ControlFlowData*)user_data; + Drawing_t *drawing = cfd->drawing; + GtkTreeView *treeview = cfd->process_list->process_list_widget; + gint *path_indices; + gint height; + + path_indices = gtk_tree_path_get_indices (arg1); + + height = get_cell_height( + GTK_TREE_VIEW(treeview)); + drawing->horizontal_sel = height * path_indices[0]; + g_critical("new hor sel : %i", drawing->horizontal_sel); +} + + /* mouse click */ static gboolean button_press_event( GtkWidget *widget, GdkEventButton *event, gpointer user_data ) @@ -596,6 +622,7 @@ Drawing_t *drawing_construct(ControlFlowData *control_flow_data) drawing->damage_begin = 0; drawing->damage_end = 0; + drawing->horizontal_sel = -1; //gtk_widget_set_size_request(drawing->drawing_area->window, 50, 50); g_object_set_data_full( diff --git a/ltt/branches/poly/lttv/modules/gui/controlflow/drawing.h b/ltt/branches/poly/lttv/modules/gui/controlflow/drawing.h index 52360435..30b70f1e 100644 --- a/ltt/branches/poly/lttv/modules/gui/controlflow/drawing.h +++ b/ltt/branches/poly/lttv/modules/gui/controlflow/drawing.h @@ -38,6 +38,7 @@ typedef enum _draw_color { COL_BLACK, COL_WHITE, COL_WAIT_FORK, COL_WAIT_CPU, + COL_EXIT, COL_ZOMBIE, COL_WAIT, COL_RUN, @@ -98,6 +99,9 @@ struct _Drawing_t { LttTime last_start; GdkGC *dotted_gc; GdkGC *gc; + + /* Position of the horizontal selector, -1 for none */ + gint horizontal_sel; }; Drawing_t *drawing_construct(ControlFlowData *control_flow_data); @@ -154,4 +158,12 @@ void drawing_data_request_begin(EventsRequest *events_request, LttvTracesetState *tss); void drawing_chunk_begin(EventsRequest *events_request, LttvTracesetState *tss); + + +void +tree_row_activated(GtkTreeModel *treemodel, + GtkTreePath *arg1, + GtkTreeViewColumn *arg2, + gpointer user_data); + #endif // _DRAWING_H diff --git a/ltt/branches/poly/lttv/modules/gui/controlflow/eventhooks.c b/ltt/branches/poly/lttv/modules/gui/controlflow/eventhooks.c index bde5c197..c422e3e9 100644 --- a/ltt/branches/poly/lttv/modules/gui/controlflow/eventhooks.c +++ b/ltt/branches/poly/lttv/modules/gui/controlflow/eventhooks.c @@ -284,6 +284,8 @@ static __inline PropertiesLine prepare_status_line(LttvProcessState *process) prop_line.color = drawing_colors[COL_WAIT_FORK]; else if(process->state->s == LTTV_STATE_WAIT_CPU) prop_line.color = drawing_colors[COL_WAIT_CPU]; + else if(process->state->s == LTTV_STATE_EXIT) + prop_line.color = drawing_colors[COL_EXIT]; else if(process->state->s == LTTV_STATE_ZOMBIE) prop_line.color = drawing_colors[COL_ZOMBIE]; else if(process->state->s == LTTV_STATE_WAIT) @@ -1852,105 +1854,102 @@ int before_execmode_hook(void *hook_data, void *call_data) * items corresponding to the state before it changes : now is the right * time to do it. */ + /* For the pid */ + LttvProcessState *process = tfs->process; + g_assert(process != NULL); - { - /* For the pid */ - LttvProcessState *process = tfs->process; - g_assert(process != NULL); + guint pid = process->pid; - guint pid = process->pid; - - /* Well, the process_out existed : we must get it in the process hash - * or add it, and draw its items. - */ - /* Add process to process list (if not present) */ - guint y = 0, height = 0, pl_height = 0; - HashedProcessData *hashed_process_data = NULL; - ProcessList *process_list = - guicontrolflow_get_process_list(control_flow_data); - LttTime birth = process->creation_time; - const gchar *name = g_quark_to_string(process->name); - - if(processlist_get_process_pixels(process_list, + /* Well, the process_out existed : we must get it in the process hash + * or add it, and draw its items. + */ + /* Add process to process list (if not present) */ + guint y = 0, height = 0, pl_height = 0; + HashedProcessData *hashed_process_data = NULL; + ProcessList *process_list = + guicontrolflow_get_process_list(control_flow_data); + LttTime birth = process->creation_time; + const gchar *name = g_quark_to_string(process->name); + + if(processlist_get_process_pixels(process_list, + pid, + process->last_cpu, + &birth, + tfc->t_context->index, + &y, + &height, + &hashed_process_data) == 1) + { + g_assert(pid == 0 || pid != process->ppid); + /* Process not present */ + processlist_add(process_list, + pid, + process->last_cpu, + process->ppid, + &birth, + tfc->t_context->index, + name, + &pl_height, + &hashed_process_data); + processlist_get_process_pixels(process_list, pid, process->last_cpu, &birth, tfc->t_context->index, &y, &height, - &hashed_process_data) == 1) - { - g_assert(pid == 0 || pid != process->ppid); - /* Process not present */ - processlist_add(process_list, - pid, - process->last_cpu, - process->ppid, - &birth, - tfc->t_context->index, - name, - &pl_height, - &hashed_process_data); - processlist_get_process_pixels(process_list, - pid, - process->last_cpu, - &birth, - tfc->t_context->index, - &y, - &height, - &hashed_process_data); - drawing_insert_square( drawing, y, height); - } + &hashed_process_data); + drawing_insert_square( drawing, y, height); + } + + /* Now, the process is in the state hash and our own process hash. + * We definitely can draw the items related to the ending state. + */ - /* Now, the process is in the state hash and our own process hash. - * We definitely can draw the items related to the ending state. - */ - - /* Check if the x position is unset. In can have been left unset by - * a draw closure from a after chunk hook. This should never happen, - * because it must be set by before chunk hook to the damage_begin - * value. - */ - g_assert(hashed_process_data->x.over != -1); - { - guint x; - DrawContext draw_context; - - convert_time_to_pixels( - time_window.start_time, - end_time, - evtime, - width, - &x); - - /* Now create the drawing context that will be used to draw - * items related to the last state. */ - draw_context.drawable = drawing->pixmap; - draw_context.gc = drawing->gc; - draw_context.pango_layout = drawing->pango_layout; - draw_context.drawinfo.start.x = hashed_process_data->x.over; - draw_context.drawinfo.end.x = x; + /* Check if the x position is unset. In can have been left unset by + * a draw closure from a after chunk hook. This should never happen, + * because it must be set by before chunk hook to the damage_begin + * value. + */ + g_assert(hashed_process_data->x.over != -1); + { + guint x; + DrawContext draw_context; - 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.start_time, + end_time, + 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; + /* 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.over; + draw_context.drawinfo.end.x = x; + + draw_context.drawinfo.y.over = y+1; + draw_context.drawinfo.y.middle = y+(height/2); + draw_context.drawinfo.y.under = y+height; + + draw_context.drawinfo.start.offset.over = 0; + draw_context.drawinfo.start.offset.middle = 0; + draw_context.drawinfo.start.offset.under = 0; + draw_context.drawinfo.end.offset.over = 0; + draw_context.drawinfo.end.offset.middle = 0; + draw_context.drawinfo.end.offset.under = 0; - { - /* Draw the line */ - PropertiesLine prop_line = prepare_execmode_line(process); - draw_line((void*)&prop_line, (void*)&draw_context); + { + /* Draw the line */ + PropertiesLine prop_line = prepare_execmode_line(process); + draw_line((void*)&prop_line, (void*)&draw_context); - } - /* become the last x position */ - hashed_process_data->x.over = x; } + /* become the last x position */ + hashed_process_data->x.over = x; } } @@ -2067,7 +2066,166 @@ int after_execmode_hook(void *hook_data, void *call_data) } -/* after_fork_hook + +/* before_process_hook + * + * Draw lines for process event. + * + * @param hook_data ControlFlowData structure of the viewer. + * @param call_data Event context. + * + * This function adds items to be drawn in a queue for each process. + * + */ +int before_process_hook(void *hook_data, void *call_data) +{ + EventsRequest *events_request = (EventsRequest*)hook_data; + ControlFlowData *control_flow_data = events_request->viewer_data; + Drawing_t *drawing = control_flow_data->drawing; + + LttvTracefileContext *tfc = (LttvTracefileContext *)call_data; + + LttvTracefileState *tfs = (LttvTracefileState *)call_data; + LttvTraceState *ts =(LttvTraceState *)LTTV_TRACEFILE_CONTEXT(tfs)->t_context; + + LttEvent *e; + e = tfc->e; + + LttTime evtime = ltt_event_time(e); + TimeWindow time_window = + lttvwindow_get_time_window(control_flow_data->tab); + + LttTime end_time = ltt_time_add(time_window.start_time, + 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; + + if(strcmp(ltt_eventtype_name(ltt_event_eventtype(e)),"process") == 0) { + + guint sub_id; + { + LttField *f = ltt_event_field(e); + LttField *element; + element = ltt_field_member(f,0); + sub_id = ltt_event_get_long_unsigned(e,element); + } + + if(sub_id == 3) { /* exit */ + + /* Add process to process list (if not present) */ + LttvProcessState *process = tfs->process; + guint pid = process->pid; + LttTime birth; + guint y = 0, height = 0, pl_height = 0; + HashedProcessData *hashed_process_data = NULL; + + ProcessList *process_list = + guicontrolflow_get_process_list(control_flow_data); + + g_assert(process != NULL); + + birth = process->creation_time; + const gchar *name = g_quark_to_string(process->name); + + if(processlist_get_process_pixels(process_list, + pid, + process->last_cpu, + &birth, + tfc->t_context->index, + &y, + &height, + &hashed_process_data) == 1) + { + g_assert(pid == 0 || pid != process->ppid); + /* Process not present */ + processlist_add(process_list, + pid, + process->last_cpu, + process->ppid, + &birth, + tfc->t_context->index, + name, + &pl_height, + &hashed_process_data); + processlist_get_process_pixels(process_list, + pid, + process->last_cpu, + &birth, + tfc->t_context->index, + &y, + &height, + &hashed_process_data); + drawing_insert_square( control_flow_data->drawing, y, height); + } + + /* Now, the process is in the state hash and our own process hash. + * We definitely can draw the items related to the ending state. + */ + + /* Check if the x position is unset. In can have been left unset by + * a draw closure from a after chunk hook. This should never happen, + * because it must be set by before chunk hook to the damage_begin + * value. + */ + g_assert(hashed_process_data->x.over != -1); + { + guint x; + DrawContext draw_context; + + convert_time_to_pixels( + time_window.start_time, + end_time, + evtime, + width, + &x); + + /* Now create the drawing context that will be used to draw + * items related to the last state. */ + draw_context.drawable = drawing->pixmap; + draw_context.gc = drawing->gc; + draw_context.pango_layout = drawing->pango_layout; + draw_context.drawinfo.start.x = hashed_process_data->x.middle; + draw_context.drawinfo.end.x = x; + + draw_context.drawinfo.y.over = y+1; + draw_context.drawinfo.y.middle = y+(height/2); + draw_context.drawinfo.y.under = y+height; + + draw_context.drawinfo.start.offset.over = 0; + draw_context.drawinfo.start.offset.middle = 0; + draw_context.drawinfo.start.offset.under = 0; + draw_context.drawinfo.end.offset.over = 0; + draw_context.drawinfo.end.offset.middle = 0; + draw_context.drawinfo.end.offset.under = 0; + + { + /* Draw the line */ + PropertiesLine prop_line = prepare_status_line(process); + draw_line((void*)&prop_line, (void*)&draw_context); + + } + /* become the last x position */ + hashed_process_data->x.middle = x; + } + + } + + + } + return 0; + +} + + + + + + +/* after_process_hook * * Create the processlist entry for the child process. Put the last * position in x at the current time value. @@ -2078,7 +2236,7 @@ int after_execmode_hook(void *hook_data, void *call_data) * This function adds items to be drawn in a queue for each process. * */ -int after_fork_hook(void *hook_data, void *call_data) +int after_process_hook(void *hook_data, void *call_data) { EventsRequest *events_request = (EventsRequest*)hook_data; ControlFlowData *control_flow_data = events_request->viewer_data; @@ -2107,18 +2265,19 @@ int after_fork_hook(void *hook_data, void *call_data) if(strcmp(ltt_eventtype_name(ltt_event_eventtype(e)),"process") == 0) { guint sub_id; - guint child_pid; + guint param1; { LttField *f = ltt_event_field(e); LttField *element; element = ltt_field_member(f,0); sub_id = ltt_event_get_long_unsigned(e,element); element = ltt_field_member(f,1); - child_pid = ltt_event_get_long_unsigned(e,element); + param1 = ltt_event_get_long_unsigned(e,element); } if(sub_id == 2) { /* fork */ - + + guint child_pid = param1; /* Add process to process list (if not present) */ LttvProcessState *process_child; LttTime birth; @@ -2179,7 +2338,67 @@ int after_fork_hook(void *hook_data, void *call_data) hashed_process_data_child->x.middle = new_x; hashed_process_data_child->x.under = new_x; + } else if(sub_id == 3) { /* exit */ + + /* Add process to process list (if not present) */ + LttvProcessState *process = tfs->process; + guint pid = process->pid; + LttTime birth; + guint y = 0, height = 0, pl_height = 0; + HashedProcessData *hashed_process_data = NULL; + + ProcessList *process_list = + guicontrolflow_get_process_list(control_flow_data); + + + /* It should exist, because we are after the state update. */ + g_assert(process != NULL); + + birth = process->creation_time; + const gchar *name = g_quark_to_string(process->name); + + if(processlist_get_process_pixels(process_list, + pid, + process->last_cpu, + &birth, + tfc->t_context->index, + &y, + &height, + &hashed_process_data) == 1) + { + g_assert(pid == 0 || pid != process->ppid); + /* Process not present */ + processlist_add(process_list, + pid, + process->last_cpu, + process->ppid, + &birth, + tfc->t_context->index, + name, + &pl_height, + &hashed_process_data); + processlist_get_process_pixels(process_list, + pid, + process->last_cpu, + &birth, + tfc->t_context->index, + &y, + &height, + &hashed_process_data); + drawing_insert_square( control_flow_data->drawing, y, height); + } + + guint new_x; + convert_time_to_pixels( + time_window.start_time, + end_time, + evtime, + width, + &new_x); + hashed_process_data->x.middle = new_x; } + + } return 0; @@ -2708,8 +2927,6 @@ void draw_closure(gpointer key, gpointer value, gpointer user_data) } - /* special case LTTV_STATE_WAIT : CPU is unknown. */ - /* become the last x position */ hashed_process_data->x.middle = x; } diff --git a/ltt/branches/poly/lttv/modules/gui/controlflow/eventhooks.h b/ltt/branches/poly/lttv/modules/gui/controlflow/eventhooks.h index 96110def..9d0d1957 100644 --- a/ltt/branches/poly/lttv/modules/gui/controlflow/eventhooks.h +++ b/ltt/branches/poly/lttv/modules/gui/controlflow/eventhooks.h @@ -85,7 +85,8 @@ int before_schedchange_hook(void *hook_data, void *call_data); int after_schedchange_hook(void *hook_data, void *call_data); int before_execmode_hook(void *hook_data, void *call_data); int after_execmode_hook(void *hook_data, void *call_data); -int after_fork_hook(void *hook_data, void *call_data); +int before_process_hook(void *hook_data, void *call_data); +int after_process_hook(void *hook_data, void *call_data); void draw_closure(gpointer key, gpointer value, gpointer user_data); -- 2.34.1