*/
static void request_background_data(ControlFlowData *resourceview_data)
{
- LttvTracesetContext * tsc =
- lttvwindow_get_traceset_context(resourceview_data->tab);
- gint num_traces = lttv_traceset_number(tsc->ts);
+ LttvTraceset* ts =
+ lttvwindow_get_traceset(resourceview_data->tab);
+ gint num_traces = lttv_traceset_number(ts);
gint i;
LttvTrace *trace;
LttvTraceState *tstate;
resourceview_data->background_info_waiting = 0;
for(i=0;i<num_traces;i++) {
- trace = lttv_traceset_get(tsc->ts, i);
- tstate = LTTV_TRACE_STATE(tsc->traces[i]);
-
+ trace = lttv_traceset_get(ts, i);
+
if(lttvwindowtraces_get_ready(g_quark_from_string("state"),trace)==FALSE
- && !tstate->has_precomputed_states) {
+ && !ts->has_precomputed_states) {
if(lttvwindowtraces_get_in_progress(g_quark_from_string("state"),
trace) == FALSE) {
int event_selected_hook(void *hook_data, void *call_data)
{
- ControlFlowData *resourceview_data = (ControlFlowData*) hook_data;
guint *event_number = (guint*) call_data;
g_debug("DEBUG : event selected by main window : %u", *event_number);
static void soft_irq_set_line_color(PropertiesLine *prop_line, LttvSoftIRQState *s)
{
- GQuark present_state;
if(s->running)
prop_line->color = drawing_colors_soft_irq[COL_SOFT_IRQ_BUSY];
else if(s->pending)
static void trap_set_line_color(PropertiesLine *prop_line, LttvTrapState *s)
{
- GQuark present_state;
if(s->running == 0)
prop_line->color = drawing_colors_trap[COL_TRAP_IDLE];
else
int before_schedchange_hook(void *hook_data, void *call_data)
{
- LttvTraceHook *th = (LttvTraceHook*)hook_data;
- EventsRequest *events_request = (EventsRequest*)th->hook_data;
- ControlFlowData *resourceview_data = events_request->viewer_data;
- LttvTracefileContext *tfc = (LttvTracefileContext *)call_data;
+ LttvEvent *event;
+ LttvTraceState *ts;
- LttvTracefileState *tfs = (LttvTracefileState *)call_data;
- LttvTraceState *ts = (LttvTraceState *)tfc->t_context;
+ event = (LttvEvent *) call_data;
+ if (strcmp(lttv_traceset_get_name_from_event(event),"sched_switch") != 0)
+ return FALSE;
- LttEvent *e;
- e = ltt_tracefile_get_event(tfc->tf);
- gint target_pid_saved = tfc->target_pid;
+ ControlFlowData *resourceview_data = (ControlFlowData*)hook_data;
- LttTime evtime = ltt_event_time(e);
- LttvFilter *filter = resourceview_data->filter;
+ LttTime evtime = lttv_event_get_timestamp(event);
/* we are in a schedchange, before the state update. We must draw the
* items corresponding to the state before it changes : now is the right
*/
guint pid_out;
- guint pid_in;
- pid_out = ltt_event_get_long_unsigned(e, lttv_trace_get_hook_field(th, 0));
- pid_in = ltt_event_get_long_unsigned(e, lttv_trace_get_hook_field(th, 1));
+ pid_out = lttv_event_get_long(event, "prev_tid");
// TODO: can't we reenable this? pmf
// if(pid_in != 0 && pid_out != 0) {
// /* not a transition to/from idle */
// return 0;
// }
- tfc->target_pid = pid_out;
- guint cpu = tfs->cpu;
+ guint cpu = lttv_traceset_get_cpuid_from_event(event);
+ ts = event->state;
- guint trace_num = ts->parent.index;
- /* Add process to process list (if not present) */
- guint pl_height = 0;
+ guint trace_num = lttv_traceset_get_trace_index_from_event(event);
+
+ /* Add process to process list (if not present) */
HashedResourceData *hashed_process_data = NULL;
- ProcessList *process_list = resourceview_data->process_list;
hashed_process_data = resourcelist_obtain_cpu(resourceview_data, trace_num, cpu);
prop_line.line_width = STATE_LINE_WIDTH;
prop_line.style = GDK_LINE_SOLID;
prop_line.y = MIDDLE;
- cpu_set_line_color(&prop_line, tfs->cpu_state);
+ cpu_set_line_color(&prop_line, &(ts->cpu_states[cpu]));
draw_line((void*)&prop_line, (void*)&draw_context);
}
*/
int after_schedchange_hook(void *hook_data, void *call_data)
{
- LttvTraceHook *th = (LttvTraceHook*)hook_data;
- EventsRequest *events_request = (EventsRequest*)th->hook_data;
- ControlFlowData *resourceview_data = events_request->viewer_data;
- LttvTracefileContext *tfc = (LttvTracefileContext *)call_data;
- LttvTracefileState *tfs = (LttvTracefileState *)call_data;
- LttvTraceState *ts = (LttvTraceState *)tfc->t_context;
- LttEvent *e;
+ LttvEvent *event;
- e = ltt_tracefile_get_event(tfc->tf);
+ event = (LttvEvent *) call_data;
+
+ if (strcmp(lttv_traceset_get_name_from_event(event),"sched_switch") != 0)
+ return FALSE;
+
+ ControlFlowData *resourceview_data = (ControlFlowData*) hook_data;
+ LttvTraceState *ts = event->state;
+#ifdef BABEL_CLEANUP
LttvFilter *filter = resourceview_data->filter;
if(filter != NULL && filter->head != NULL)
if(!lttv_filter_tree_parse(filter->head,e,tfc->tf,
tfc->t_context->t,tfc,NULL,NULL))
return FALSE;
+#endif
- LttTime evtime = ltt_event_time(e);
+ LttTime evtime = lttv_event_get_timestamp(event);
/* Add process to process list (if not present) */
LttvProcessState *process_in;
- LttTime birth;
- guint pl_height = 0;
HashedResourceData *hashed_process_data_in = NULL;
ProcessList *process_list = resourceview_data->process_list;
- guint pid_in;
- {
- guint pid_out;
- pid_out = ltt_event_get_long_unsigned(e, lttv_trace_get_hook_field(th, 0));
- pid_in = ltt_event_get_long_unsigned(e, lttv_trace_get_hook_field(th, 1));
- }
-
-
/* Find process pid_in in the list... */
//process_in = lttv_state_find_process(ts, ANY_CPU, pid_in);
//process_in = tfs->process;
- guint cpu = tfs->cpu;
- guint trace_num = ts->parent.index;
+ guint cpu = lttv_traceset_get_cpuid_from_event(event);
+ guint trace_num = lttv_traceset_get_trace_index_from_event(event);
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, cpuq, trace_num);
hashed_process_data_in = resourcelist_obtain_cpu(resourceview_data, trace_num, cpu);
int before_execmode_hook(void *hook_data, void *call_data)
{
- LttvTraceHook *th = (LttvTraceHook*)hook_data;
- EventsRequest *events_request = (EventsRequest*)th->hook_data;
- ControlFlowData *resourceview_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);
+ LttvEvent *event;
+ guint cpu;
+ guint pid = 0;
+ LttvTraceState *ts;
+ LttvProcessState *process;
before_execmode_hook_irq(hook_data, call_data);
before_execmode_hook_soft_irq(hook_data, call_data);
+#ifdef TRAP_NO_EXIST
before_execmode_hook_trap(hook_data, call_data);
-
+#endif
/* we are in a execmode, before the state update. We must draw the
* items corresponding to the state before it changes : now is the right
* time to do it.
*/
+ event = (LttvEvent *) call_data;
+ if ((strncmp(lttv_traceset_get_name_from_event(event),"sys_", sizeof("sys_") - 1) == 0)
+ ||(strcmp(lttv_traceset_get_name_from_event(event),"exit_syscall") == 0)
+ ||(strncmp(lttv_traceset_get_name_from_event(event),"irq_handler_",sizeof("irq_handler_") -1) == 0)
+ ||(strncmp(lttv_traceset_get_name_from_event(event),"softirq_", sizeof("softirq_") - 1) == 0)) {
+
+ LttTime evtime = lttv_event_get_timestamp(event);
+ ControlFlowData *resourceview_data = (ControlFlowData*)hook_data;
+
/* For the pid */
- guint cpu = tfs->cpu;
+ LttvTraceset *traceSet = lttvwindow_get_traceset(resourceview_data->tab);
+
+ cpu = lttv_traceset_get_cpuid_from_event(event);
+ ts = event->state;
+
+ guint trace_num = lttv_traceset_get_trace_index_from_event(event);
- guint trace_num = ts->parent.index;
- LttvProcessState *process = ts->running_process[cpu];
+ process = ts->running_process[cpu];
g_assert(process != NULL);
/* Well, the process_out existed : we must get it in the process hash
* or add it, and draw its items.
*/
- /* Add process to process list (if not present) */
- guint pl_height = 0;
+ /* Add process to process list (if not present) */
HashedResourceData *hashed_process_data = NULL;
ProcessList *process_list = resourceview_data->process_list;
-
- LttTime birth = process->creation_time;
if(likely(process_list->current_hash_data[trace_num][cpu] != NULL)) {
hashed_process_data = process_list->current_hash_data[trace_num][cpu];
prop_line.line_width = STATE_LINE_WIDTH;
prop_line.style = GDK_LINE_SOLID;
prop_line.y = MIDDLE;
- cpu_set_line_color(&prop_line, tfs->cpu_state);
+ cpu_set_line_color(&prop_line, &ts->cpu_states[cpu]);
draw_line((void*)&prop_line, (void*)&draw_context);
}
/* become the last x position */
convert_pixels_to_time(width, x+1, time_window,
&hashed_process_data->next_good_time);
}
+ }
}
-
return 0;
}
int before_execmode_hook_irq(void *hook_data, void *call_data)
{
- LttvTraceHook *th = (LttvTraceHook*)hook_data;
- EventsRequest *events_request = (EventsRequest*)th->hook_data;
- ControlFlowData *resourceview_data = events_request->viewer_data;
-
- LttvTracefileContext *tfc = (LttvTracefileContext *)call_data;
-
- LttvTracefileState *tfs = (LttvTracefileState *)call_data;
- LttvTraceState *ts = (LttvTraceState *)tfc->t_context;
- struct marker_info *minfo;
-
- LttEvent *e;
- e = ltt_tracefile_get_event(tfc->tf);
-
- LttTime evtime = ltt_event_time(e);
+ LttvEvent *event;
- LttTrace *trace = tfc->t_context->t;
+ event = (LttvEvent *) call_data;
+
+ LttTime evtime = lttv_event_get_timestamp(event);
+ ControlFlowData *resourceview_data = (ControlFlowData*)hook_data;
/* we are in a execmode, before the state update. We must draw the
* items corresponding to the state before it changes : now is the right
/* For the pid */
guint64 irq;
- guint cpu = tfs->cpu;
+ guint cpu = lttv_traceset_get_cpuid_from_event(event);
+ LttvTraceset *traceSet = lttvwindow_get_traceset(resourceview_data->tab);
+ LttvTraceState *ts = event->state;;
/*
* Check for LTT_CHANNEL_KERNEL channel name and event ID
* corresponding to LTT_EVENT_IRQ_ENTRY or LTT_EVENT_IRQ_EXIT.
*/
- if (tfc->tf->name != LTT_CHANNEL_KERNEL)
- return 0;
- minfo = marker_get_info_from_id(tfc->tf->mdata, e->event_id);
- g_assert(minfo != NULL);
- if (minfo->name == LTT_EVENT_IRQ_ENTRY) {
- irq = ltt_event_get_long_unsigned(e, lttv_trace_get_hook_field(th, 0));
- } else if (minfo->name == LTT_EVENT_IRQ_EXIT) {
+ if (strncmp(lttv_traceset_get_name_from_event(event),"irq_handler_entry",sizeof("irq_handler_entry")) == 0) {
+ irq = lttv_event_get_long(event, "irq");
+ } else if (strncmp(lttv_traceset_get_name_from_event(event),"irq_handler_exit",sizeof("irq_handler_exit")) == 0) {
gint len = ts->cpu_states[cpu].irq_stack->len;
if(len) {
irq = g_array_index(ts->cpu_states[cpu].irq_stack, gint, len-1);
} else
return 0;
- guint trace_num = ts->parent.index;
+ guint trace_num = lttv_traceset_get_trace_index_from_event(event);
/* 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 pl_height = 0;
+ /* Add process to process list (if not present) */
HashedResourceData *hashed_process_data = NULL;
- ProcessList *process_list = resourceview_data->process_list;
hashed_process_data = resourcelist_obtain_irq(resourceview_data, trace_num, irq);
// TODO: fix this, it's ugly and slow:
GQuark name;
{
gchar *str;
- str = g_strdup_printf("IRQ %" PRIu64 " [%s]", irq, (char*)g_quark_to_string(ts->irq_names[irq]));
+ str = g_strdup_printf("IRQ %" PRIu64 " [%s]", irq,
+ (char*)g_quark_to_string(ts->name_tables->irq_names[irq]));
name = g_quark_from_string(str);
g_free(str);
}
int before_execmode_hook_soft_irq(void *hook_data, void *call_data)
{
- LttvTraceHook *th = (LttvTraceHook*)hook_data;
- EventsRequest *events_request = (EventsRequest*)th->hook_data;
- ControlFlowData *resourceview_data = events_request->viewer_data;
- LttvTracefileContext *tfc = (LttvTracefileContext *)call_data;
+ LttvEvent *event;
+ LttvTraceState *ts;
- LttvTracefileState *tfs = (LttvTracefileState *)call_data;
- LttvTraceState *ts = (LttvTraceState *)tfc->t_context;
- struct marker_info *minfo;
-
- LttEvent *e;
- e = ltt_tracefile_get_event(tfc->tf);
-
- LttTime evtime = ltt_event_time(e);
-
- LttTrace *trace = tfc->t_context->t;
+ event = (LttvEvent *) call_data;
+
+
+
/* we are in a execmode, before the state update. We must draw the
* items corresponding to the state before it changes : now is the right
/* For the pid */
guint64 softirq;
- guint cpu = tfs->cpu;
+
/*
* Check for LTT_CHANNEL_KERNEL channel name and event ID
* corresponding to LTT_EVENT_SOFT_IRQ_RAISE, LTT_EVENT_SOFT_IRQ_ENTRY
* or LTT_EVENT_SOFT_IRQ_EXIT.
*/
- if (tfc->tf->name != LTT_CHANNEL_KERNEL)
- return 0;
- minfo = marker_get_info_from_id(tfc->tf->mdata, e->event_id);
- g_assert(minfo != NULL);
- if (minfo->name == LTT_EVENT_SOFT_IRQ_RAISE
- || minfo->name == LTT_EVENT_SOFT_IRQ_ENTRY) {
- softirq = ltt_event_get_long_unsigned(e, lttv_trace_get_hook_field(th, 0));
- } else if (minfo->name == LTT_EVENT_SOFT_IRQ_EXIT) {
- gint len = ts->cpu_states[cpu].softirq_stack->len;
- if(len) {
- softirq = g_array_index(ts->cpu_states[cpu].softirq_stack, gint, len-1);
- }
- else {
- return 0;
- }
- } else
+
+ if (strncmp(lttv_traceset_get_name_from_event(event),"softirq_entry",sizeof("softirq_entry")) == 0
+ || strncmp(lttv_traceset_get_name_from_event(event),"softirq_raise",sizeof("softirq_raise")) == 0
+ || strncmp(lttv_traceset_get_name_from_event(event),"softirq_exit",sizeof("softirq_exit")) == 0 ) {
+
+ softirq = lttv_event_get_long_unsigned(event, "vec");
+
+ } else {
return 0;
+ }
- guint trace_num = ts->parent.index;
+ LttTime evtime = lttv_event_get_timestamp(event);
+ ControlFlowData *resourceview_data = (ControlFlowData*)hook_data;
+ LttvTraceset *traceSet = lttvwindow_get_traceset(resourceview_data->tab);
+ guint cpu = lttv_traceset_get_cpuid_from_event(event);
+ ts = event->state;
+ guint trace_num = lttv_traceset_get_trace_index_from_event(event);
/* 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 pl_height = 0;
+ /* Add process to process list (if not present) */
HashedResourceData *hashed_process_data = NULL;
- ProcessList *process_list = resourceview_data->process_list;
hashed_process_data = resourcelist_obtain_soft_irq(resourceview_data, trace_num, softirq);
&hashed_process_data->next_good_time);
}
}
-
+
return 0;
}
-
+#ifdef TRAP_NO_EXIST
int before_execmode_hook_trap(void *hook_data, void *call_data)
{
LttvTraceHook *th = (LttvTraceHook*)hook_data;
LttTime evtime = ltt_event_time(e);
- LttTrace *trace = tfc->t_context->t;
-
/* we are in a execmode, before the state update. We must draw the
* items corresponding to the state before it changes : now is the right
* time to do it.
/* 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 pl_height = 0;
+ /* Add process to process list (if not present) */
HashedResourceData *hashed_process_data = NULL;
- ProcessList *process_list = resourceview_data->process_list;
hashed_process_data = resourcelist_obtain_trap(resourceview_data, trace_num, trap);
return 0;
}
-
-
+#endif
+#ifdef BABEL_CLEANUP
+//TODO investigate the use of block dev resource
int before_bdev_event_hook(void *hook_data, void *call_data)
{
- LttvTraceHook *th = (LttvTraceHook*)hook_data;
- EventsRequest *events_request = (EventsRequest*)th->hook_data;
- ControlFlowData *resourceview_data = events_request->viewer_data;
-
- LttvTracefileContext *tfc = (LttvTracefileContext *)call_data;
-
- LttvTracefileState *tfs = (LttvTracefileState *)call_data;
- LttvTraceState *ts = (LttvTraceState *)tfc->t_context;
+LttvEvent *event;
+ guint cpu;
+ guint pid = 0;
+ LttvTraceState *ts;
+ LttvProcessState *process;
- LttEvent *e;
- e = ltt_tracefile_get_event(tfc->tf);
-
- LttTime evtime = ltt_event_time(e);
/* we are in a execmode, before the state update. We must draw the
* items corresponding to the state before it changes : now is the right
* time to do it.
*/
+
+ event = (LttvEvent *) call_data;
+ if (strcmp(lttv_traceset_get_name_from_event(event),"block_rq_issue") != 0 && strcmp(lttv_traceset_get_name_from_event(event),"block_rq_complete") != 0)
+ return FALSE;
+
+
+ ControlFlowData *resourceview_data = (ControlFlowData*) hook_data;
+
+ LttvTraceState *ts = event->state;
/* For the pid */
- guint cpu = tfs->cpu;
guint8 major = ltt_event_get_long_unsigned(e, lttv_trace_get_hook_field(th, 0));
guint8 minor = ltt_event_get_long_unsigned(e, lttv_trace_get_hook_field(th, 1));
- guint oper = ltt_event_get_long_unsigned(e, lttv_trace_get_hook_field(th, 2));
gint devcode_gint = MKDEV(major,minor);
- guint trace_num = ts->parent.index;
+ guint trace_num = lttv_traceset_get_trace_index_from_event(event);
LttvBdevState *bdev = g_hash_table_lookup(ts->bdev_states, &devcode_gint);
/* the result of the lookup might be NULL. that's ok, the rest of the function
/* 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 pl_height = 0;
+ /* Add process to process list (if not present) */
HashedResourceData *hashed_process_data = NULL;
- ProcessList *process_list = resourceview_data->process_list;
// LttTime birth = process->creation_time;
// if(likely(process_list->current_hash_data[trace_num][cpu] != NULL)) {
return 0;
}
-
+#endif
gint update_time_window_hook(void *hook_data, void *call_data)
{
ControlFlowData *resourceview_data = (ControlFlowData*) hook_data;
/* Same scale (scrolling) */
g_info("scrolling");
LttTime *ns = &new_time_window->start_time;
- LttTime *nw = &new_time_window->time_width;
LttTime *os = &old_time_window->start_time;
- LttTime *ow = &old_time_window->time_width;
LttTime old_end = old_time_window->end_time;
LttTime new_end = new_time_window->end_time;
//if(ns<os+w<ns+w)
gint update_current_time_hook(void *hook_data, void *call_data)
{
ControlFlowData *resourceview_data = (ControlFlowData*)hook_data;
- Drawing_t *drawing = resourceview_data->drawing;
LttTime current_time = *((LttTime*)call_data);
}
LttTime time_end = ltt_time_add(time_begin, width);
- LttvTracesetContext * tsc =
- lttvwindow_get_traceset_context(resourceview_data->tab);
-
- LttTime trace_start = tsc->time_span.start_time;
- LttTime trace_end = tsc->time_span.end_time;
+ LttvTraceset * ts = lttvwindow_get_traceset(resourceview_data->tab);
+
+ TimeInterval time_span = lttv_traceset_get_time_span_real(ts);
+ LttTime trace_start = time_span.start_time;
+ LttTime trace_end = time_span.end_time;
g_info("New current time HOOK : %lu, %lu", current_time.tv_sec,
current_time.tv_nsec);
typedef struct _ClosureData {
EventsRequest *events_request;
- LttvTracesetState *tss;
LttTime end_time;
guint x_end;
} ClosureData;
EventsRequest *events_request = closure_data->events_request;
ControlFlowData *resourceview_data = events_request->viewer_data;
-
- LttvTracesetState *tss = closure_data->tss;
- LttvTracesetContext *tsc = (LttvTracesetContext*)tss;
+ LttvTraceset *ts = lttvwindow_get_traceset(resourceview_data->tab);
LttTime evtime = closure_data->end_time;
#ifdef EXTRA_CHECK
g_assert(lttv_traceset_number(tsc->ts) > 0);
#endif //EXTRA_CHECK
- LttvTraceContext *tc = tsc->traces[process_info->trace_num];
- LttvTraceState *ts = (LttvTraceState*)tc;
+
+ LttvTrace *trace = lttv_traceset_get(ts,process_info->trace_num);
+ LttvTraceState *ts = trace->state;
/* Only draw for processes that are currently in the trace states */
- ProcessList *process_list = resourceview_data->process_list;
#ifdef EXTRA_CHECK
/* Should be alike when background info is ready */
if(resourceview_data->background_info_waiting==0)
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;
+ LttvTraceset *ts = (LttvTraceset*)call_data;
+
#if 0
/* Deactivate sort */
gtk_tree_sortable_set_sort_column_id(
TRACE_COLUMN,
GTK_SORT_ASCENDING);
#endif //0
- drawing_chunk_begin(events_request, tss);
+ drawing_chunk_begin(events_request, ts);
return 0;
}
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);
+ drawing_data_request_begin(events_request);
return 0;
}
-
-/*
- * after request is necessary in addition of after chunk in order to draw
- * lines until the end of the screen. after chunk just draws lines until
- * the last event.
- *
- * for each process
- * draw closing line
- * expose
- */
-int after_request(void *hook_data, void *call_data)
+void draw_closing_lines(ControlFlowData *resourceview_data,
+ EventsRequest* events_request)
{
- guint i;
- EventsRequest *events_request = (EventsRequest*)hook_data;
- ControlFlowData *resourceview_data = events_request->viewer_data;
- LttvTracesetState *tss = (LttvTracesetState*)call_data;
-
- ProcessList *process_list = resourceview_data->process_list;
- LttTime end_time = events_request->end_time;
-
+ LttTime end_time = events_request->end_time;
ClosureData closure_data;
- closure_data.events_request = (EventsRequest*)hook_data;
- closure_data.tss = tss;
+ closure_data.events_request = events_request;
closure_data.end_time = end_time;
+
TimeWindow time_window =
lttvwindow_get_time_window(resourceview_data->tab);
guint width = resourceview_data->drawing->width;
width,
&closure_data.x_end);
-
+ guint i;
/* Draw last items */
for(i=0; i<RV_RESOURCE_COUNT; i++) {
g_hash_table_foreach(resourcelist_get_resource_hash_table(resourceview_data, i), draw_closure,
}
/* Request expose */
- drawing_request_expose(events_request, tss, end_time);
+ drawing_request_expose(events_request, end_time);
+
+}
+/*
+ * after request is necessary in addition of after chunk in order to draw
+ * lines until the end of the screen. after chunk just draws lines until
+ * the last event.
+ *
+ * for each process
+ * draw closing line
+ * expose
+ */
+int after_request(void *hook_data, void *call_data)
+{
+
+ EventsRequest *events_request = (EventsRequest*)hook_data;
+ ControlFlowData *resourceview_data = events_request->viewer_data;
+
+ draw_closing_lines(resourceview_data, events_request);
+
return 0;
}
{
EventsRequest *events_request = (EventsRequest*)hook_data;
ControlFlowData *resourceview_data = events_request->viewer_data;
- LttvTracesetState *tss = (LttvTracesetState*)call_data;
- LttvTracesetContext *tsc = (LttvTracesetContext*)call_data;
- LttvTracefileContext *tfc = lttv_traceset_context_get_current_tfc(tsc);
+ LttvTraceset *ts = (LttvTraceset*)call_data;
+
LttTime end_time;
ProcessList *process_list = resourceview_data->process_list;
guint i;
- LttvTraceset *traceset = tsc->ts;
- guint nb_trace = lttv_traceset_number(traceset);
+ guint nb_trace = lttv_traceset_number(ts);
/* Only execute when called for the first trace's events request */
if(!process_list->current_hash_data)
}
g_free(process_list->current_hash_data);
process_list->current_hash_data = NULL;
-
+#ifdef BABEL_CLEANUP
if(tfc != NULL)
end_time = LTT_TIME_MIN(tfc->timestamp, events_request->end_time);
else /* end of traceset, or position now out of request : end */
end_time = events_request->end_time;
-
- ClosureData closure_data;
- closure_data.events_request = (EventsRequest*)hook_data;
- closure_data.tss = tss;
- closure_data.end_time = end_time;
-
- TimeWindow time_window =
- lttvwindow_get_time_window(resourceview_data->tab);
- guint width = resourceview_data->drawing->width;
- convert_time_to_pixels(
- time_window,
- end_time,
- width,
- &closure_data.x_end);
-
- /* Draw last items */
- for(i=0; i<RV_RESOURCE_COUNT; i++) {
- g_hash_table_foreach(resourcelist_get_resource_hash_table(resourceview_data, i), draw_closure,
- (void*)&closure_data);
- }
-#if 0
- /* Reactivate sort */
- gtk_tree_sortable_set_sort_column_id(
- GTK_TREE_SORTABLE(resourceview_data->process_list->list_store),
- GTK_TREE_SORTABLE_DEFAULT_SORT_COLUMN_ID,
- GTK_SORT_ASCENDING);
-
- update_index_to_pixmap(resourceview_data->process_list);
- /* Request a full expose : drawing scrambled */
- gtk_widget_queue_draw(resourceview_data->drawing->drawing_area);
-#endif //0
- /* Request expose (updates damages zone also) */
- drawing_request_expose(events_request, tss, end_time);
+#endif
+ draw_closing_lines(resourceview_data, events_request);
return 0;
}
*/
int before_statedump_end(void *hook_data, void *call_data)
{
- gint i;
+ LttvEvent *event;
- LttvTraceHook *th = (LttvTraceHook*)hook_data;
- EventsRequest *events_request = (EventsRequest*)th->hook_data;
- ControlFlowData *resourceview_data = events_request->viewer_data;
+ event = (LttvEvent *) call_data;
+
+ if (strcmp(lttv_traceset_get_name_from_event(event),"lttng_statedump_end") != 0)
+ return FALSE;
- LttvTracefileContext *tfc = (LttvTracefileContext *)call_data;
+ ControlFlowData *resourceview_data = (ControlFlowData*) hook_data;
- LttvTracefileState *tfs = (LttvTracefileState *)call_data;
- LttvTraceState *ts = (LttvTraceState *)tfc->t_context;
+ LttvTraceState *ts = event->state;
- LttvTracesetState *tss = (LttvTracesetState*)tfc->t_context->ts_context;
- ProcessList *process_list = resourceview_data->process_list;
- LttEvent *e;
- e = ltt_tracefile_get_event(tfc->tf);
+ gint i;
+
+#ifdef BABEL_CLEANUP
LttvFilter *filter = resourceview_data->filter;
if(filter != NULL && filter->head != NULL)
if(!lttv_filter_tree_parse(filter->head,e,tfc->tf,
tfc->t_context->t,tfc,NULL,NULL))
return FALSE;
+#endif
- LttTime evtime = ltt_event_time(e);
+ LttTime evtime = lttv_event_get_timestamp(event);
ClosureData closure_data;
- closure_data.events_request = events_request;
- closure_data.tss = tss;
+ //TODO ybrosseau 2013-03-27: Fake and event_request.
+ // We need to change the API of drawing_request_expose to ask
+ // For and control flow data only.
+ EventsRequest events_request;
+ events_request.viewer_data = resourceview_data;
+ closure_data.events_request = &events_request;
closure_data.end_time = evtime;
TimeWindow time_window =
gtk_widget_queue_draw(resourceview_data->drawing->drawing_area);
#endif //0
/* Request expose (updates damages zone also) */
- drawing_request_expose(events_request, tss, evtime);
+ drawing_request_expose(&events_request, evtime);
return 0;
+
}
projects / lttv.git / blobdiff