X-Git-Url: http://git.lttng.org./?a=blobdiff_plain;ds=sidebyside;f=ltt%2Fbranches%2Fpoly%2Flttv%2Fmodules%2Fgui%2Flttvwindow%2Flttvwindow%2Flttvwindowtraces.c;h=0de5dcc3dbe8cf3b3f1bf2173043224e51b40499;hb=313bd6fc2be6b0b81b4dde2c9355e1e2edc21291;hp=3a190006e69d04062792735723a6887049666f5b;hpb=a1a2b6492b9e18506e9429b71a90fcfff9da7f99;p=lttv.git diff --git a/ltt/branches/poly/lttv/modules/gui/lttvwindow/lttvwindow/lttvwindowtraces.c b/ltt/branches/poly/lttv/modules/gui/lttvwindow/lttvwindow/lttvwindowtraces.c index 3a190006..0de5dcc3 100644 --- a/ltt/branches/poly/lttv/modules/gui/lttvwindow/lttvwindow/lttvwindowtraces.c +++ b/ltt/branches/poly/lttv/modules/gui/lttvwindow/lttvwindow/lttvwindowtraces.c @@ -20,6 +20,10 @@ /* Here is the implementation of the API */ +#include +#include +#include + #include #include #include @@ -28,6 +32,7 @@ #include #include #include +#include // for CHUNK_NUM_EVENTS typedef struct _BackgroundRequest { @@ -48,6 +53,9 @@ typedef struct _BackgroundNotify { +/* Prototypes */ +gboolean lttvwindowtraces_process_pending_requests(LttvTrace *trace); + /* Get a trace by its path name. * * @param path path of the trace on the virtual file system. @@ -64,7 +72,6 @@ LttvTrace *lttvwindowtraces_get_trace_by_name(gchar *path) LttvTrace *trace_v = lttvwindowtraces_get_trace(i); LttTrace *trace; gchar *name; - g_assert(trace_v != NULL); trace = lttv_trace(trace_v); @@ -126,17 +133,66 @@ void lttvwindowtraces_add_trace(LttvTrace *trace) LttvAttribute *attribute; LttvAttributeValue value; guint num; + struct stat buf; + gchar attribute_path[PATH_MAX]; + if(stat(ltt_trace_name(lttv_trace(trace)), &buf)) { + g_warning("lttvwindowtraces_add_trace: Trace %s not found", + ltt_trace_name(lttv_trace(trace))); + return; + } + g_assert( + snprintf(attribute_path, PATH_MAX, "%lu:%lu", buf.st_dev, buf.st_ino) >= 0); + g_assert(attribute = LTTV_ATTRIBUTE(lttv_iattribute_find_subdir(LTTV_IATTRIBUTE(g_attribute), LTTV_TRACES))); - num = lttv_attribute_get_number(attribute); - + value = lttv_attribute_add(attribute, - num, + g_quark_from_string(attribute_path), LTTV_POINTER); *(value.v_pointer) = (gpointer)trace; + + /* create new traceset and tracesetcontext */ + LttvTraceset *ts; + LttvTracesetStats *tss; + + attribute = lttv_trace_attribute(trace); + g_assert(lttv_iattribute_find(LTTV_IATTRIBUTE(attribute), + LTTV_COMPUTATION_TRACESET, + LTTV_POINTER, + &value)); + ts = lttv_traceset_new(); + *(value.v_pointer) = ts; + + lttv_traceset_add(ts,trace); + + g_assert(lttv_iattribute_find(LTTV_IATTRIBUTE(attribute), + LTTV_COMPUTATION_TRACESET_CONTEXT, + LTTV_POINTER, + &value)); + tss = g_object_new(LTTV_TRACESET_STATS_TYPE, NULL); + *(value.v_pointer) = tss; + + lttv_context_init(LTTV_TRACESET_CONTEXT(tss), ts); + + value = lttv_attribute_add(attribute, + LTTV_REQUESTS_QUEUE, + LTTV_POINTER); + + value = lttv_attribute_add(attribute, + LTTV_REQUESTS_CURRENT, + LTTV_POINTER); + + value = lttv_attribute_add(attribute, + LTTV_NOTIFY_QUEUE, + LTTV_POINTER); + + value = lttv_attribute_add(attribute, + LTTV_NOTIFY_CURRENT, + LTTV_POINTER); + } /* Remove a trace from the global attributes */ @@ -159,7 +215,50 @@ void lttvwindowtraces_remove_trace(LttvTrace *trace) if(trace_v == trace) { /* Found */ + LttvAttribute *l_attribute; + + /* create new traceset and tracesetcontext */ + LttvTraceset *ts; + LttvTracesetStats *tss; + + l_attribute = lttv_trace_attribute(trace); + + + lttv_iattribute_remove_by_name(LTTV_IATTRIBUTE(l_attribute), + LTTV_REQUESTS_QUEUE); + + lttv_iattribute_remove_by_name(LTTV_IATTRIBUTE(l_attribute), + LTTV_REQUESTS_CURRENT); + + lttv_iattribute_remove_by_name(LTTV_IATTRIBUTE(l_attribute), + LTTV_NOTIFY_QUEUE); + + lttv_iattribute_remove_by_name(LTTV_IATTRIBUTE(l_attribute), + LTTV_NOTIFY_CURRENT); + + g_assert(lttv_iattribute_find(LTTV_IATTRIBUTE(l_attribute), + LTTV_COMPUTATION_TRACESET, + LTTV_POINTER, + &value)); + ts = (LttvTraceset*)*(value.v_pointer); + + g_assert(lttv_iattribute_find(LTTV_IATTRIBUTE(l_attribute), + LTTV_COMPUTATION_TRACESET_CONTEXT, + LTTV_POINTER, + &value)); + tss = (LttvTracesetStats*)*(value.v_pointer); + + lttv_context_fini(LTTV_TRACESET_CONTEXT(tss)); + g_object_unref(tss); + lttv_iattribute_remove_by_name(LTTV_IATTRIBUTE(l_attribute), + LTTV_COMPUTATION_TRACESET_CONTEXT); + lttv_traceset_destroy(ts); + lttv_iattribute_remove_by_name(LTTV_IATTRIBUTE(l_attribute), + LTTV_COMPUTATION_TRACESET); + + /* finally, remove the global attribute */ lttv_attribute_remove(attribute, i); + return; } } @@ -196,6 +295,13 @@ void lttvwindowtraces_background_request_queue bg_req->trace = trace; *slist = g_slist_append(*slist, bg_req); + + /* Priority lower than live servicing */ + g_idle_remove_by_data(trace); + g_idle_add_full((G_PRIORITY_HIGH_IDLE + 23), + (GSourceFunc)lttvwindowtraces_process_pending_requests, + trace, + NULL); } /** @@ -280,9 +386,14 @@ void lttvwindowtraces_background_notify_queue bg_notify->owner = owner; bg_notify->trace = trace; bg_notify->notify_time = notify_time; - bg_notify->notify_position = ltt_traceset_context_position_new(); - lttv_traceset_context_position_copy(bg_notify->notify_position, - notify_position); + if(notify_position != NULL) { + bg_notify->notify_position = ltt_traceset_context_position_new(); + lttv_traceset_context_position_copy(bg_notify->notify_position, + notify_position); + } else { + bg_notify->notify_position = NULL; + } + bg_notify->notify = lttv_hooks_new(); lttv_hooks_add_list(bg_notify->notify, notify); @@ -323,9 +434,13 @@ void lttvwindowtraces_background_notify_current bg_notify->owner = owner; bg_notify->trace = trace; bg_notify->notify_time = notify_time; - bg_notify->notify_position = ltt_traceset_context_position_new(); - lttv_traceset_context_position_copy(bg_notify->notify_position, - notify_position); + if(notify_position!= NULL) { + bg_notify->notify_position = ltt_traceset_context_position_new(); + lttv_traceset_context_position_copy(bg_notify->notify_position, + notify_position); + } else { + bg_notify->notify_position = NULL; + } bg_notify->notify = lttv_hooks_new(); lttv_hooks_add_list(bg_notify->notify, notify); @@ -366,8 +481,9 @@ void lttvwindowtraces_background_notify_remove(gpointer owner) if(bg_notify->owner == owner) { GSList *rem_iter = iter; iter=g_slist_next(iter); - lttv_traceset_context_position_destroy( - bg_notify->notify_position); + if(bg_notify->notify_position != NULL) + lttv_traceset_context_position_destroy( + bg_notify->notify_position); lttv_hooks_destroy(bg_notify->notify); g_free(bg_notify); g_slist_remove_link(*slist, rem_iter); @@ -389,8 +505,9 @@ void lttvwindowtraces_background_notify_remove(gpointer owner) if(bg_notify->owner == owner) { GSList *rem_iter = iter; iter=g_slist_next(iter); - lttv_traceset_context_position_destroy( - bg_notify->notify_position); + if(bg_notify->notify_position != NULL) + lttv_traceset_context_position_destroy( + bg_notify->notify_position); lttv_hooks_destroy(bg_notify->notify); g_free(bg_notify); g_slist_remove_link(*slist, rem_iter); @@ -401,3 +518,843 @@ void lttvwindowtraces_background_notify_remove(gpointer owner) } } + +/* Background processing helper functions */ + +void lttvwindowtraces_add_computation_hooks(LttvAttributeName module_name, + LttvTracesetContext *tsc) +{ + LttvAttribute *g_attribute = lttv_global_attributes(); + LttvAttribute *module_attribute; + LttvAttributeType type; + LttvAttributeValue value; + LttvHooks *before_chunk_traceset=NULL; + LttvHooks *before_chunk_trace=NULL; + LttvHooks *before_chunk_tracefile=NULL; + LttvHooks *event_hook=NULL; + LttvHooksById *event_hook_by_id=NULL; + LttvTracesetStats *tss = LTTV_TRACESET_STATS(tsc); + + + g_assert(module_attribute = + LTTV_ATTRIBUTE(lttv_iattribute_find_subdir(LTTV_IATTRIBUTE(g_attribute), + LTTV_COMPUTATION))); + + g_assert(module_attribute = + LTTV_ATTRIBUTE(lttv_iattribute_find_subdir( + LTTV_IATTRIBUTE(module_attribute), + module_name))); + + type = lttv_iattribute_get_by_name(LTTV_IATTRIBUTE(module_attribute), + LTTV_BEFORE_CHUNK_TRACESET, + &value); + if(type == LTTV_POINTER) { + before_chunk_traceset = (LttvHooks*)*(value.v_pointer); + } + + type = lttv_iattribute_get_by_name(LTTV_IATTRIBUTE(module_attribute), + LTTV_BEFORE_CHUNK_TRACE, + &value); + if(type == LTTV_POINTER) { + before_chunk_trace = (LttvHooks*)*(value.v_pointer); + } + + type = lttv_iattribute_get_by_name(LTTV_IATTRIBUTE(module_attribute), + LTTV_BEFORE_CHUNK_TRACEFILE, + &value); + if(type == LTTV_POINTER) { + before_chunk_tracefile = (LttvHooks*)*(value.v_pointer); + } + + type = lttv_iattribute_get_by_name(LTTV_IATTRIBUTE(module_attribute), + LTTV_EVENT_HOOK, + &value); + if(type == LTTV_POINTER) { + event_hook = (LttvHooks*)*(value.v_pointer); + } + + type = lttv_iattribute_get_by_name(LTTV_IATTRIBUTE(module_attribute), + LTTV_EVENT_HOOK_BY_ID, + &value); + if(type == LTTV_POINTER) { + event_hook_by_id = (LttvHooksById*)*(value.v_pointer); + } + + /* Call the module's hook adder */ + type = lttv_iattribute_get_by_name(LTTV_IATTRIBUTE(module_attribute), + LTTV_HOOK_ADDER, + &value); + if(type == LTTV_POINTER) { + lttv_hooks_call((LttvHooks*)*(value.v_pointer), (gpointer)tss); + } + + + + lttv_process_traceset_begin(tsc, + before_chunk_traceset, + before_chunk_trace, + before_chunk_tracefile, + event_hook, + event_hook_by_id); + +} + +void lttvwindowtraces_remove_computation_hooks(LttvAttributeName module_name, + LttvTracesetContext *tsc) +{ + LttvAttribute *g_attribute = lttv_global_attributes(); + LttvAttribute *module_attribute; + LttvAttributeType type; + LttvAttributeValue value; + LttvHooks *after_chunk_traceset=NULL; + LttvHooks *after_chunk_trace=NULL; + LttvHooks *after_chunk_tracefile=NULL; + LttvHooks *event_hook=NULL; + LttvHooksById *event_hook_by_id=NULL; + LttvTracesetStats *tss = LTTV_TRACESET_STATS(tsc); + + g_assert(module_attribute = + LTTV_ATTRIBUTE(lttv_iattribute_find_subdir(LTTV_IATTRIBUTE(g_attribute), + LTTV_COMPUTATION))); + + g_assert(module_attribute = + LTTV_ATTRIBUTE(lttv_iattribute_find_subdir( + LTTV_IATTRIBUTE(module_attribute), + module_name))); + + type = lttv_iattribute_get_by_name(LTTV_IATTRIBUTE(module_attribute), + LTTV_AFTER_CHUNK_TRACESET, + &value); + if(type == LTTV_POINTER) { + after_chunk_traceset = (LttvHooks*)*(value.v_pointer); + } + + type = lttv_iattribute_get_by_name(LTTV_IATTRIBUTE(module_attribute), + LTTV_AFTER_CHUNK_TRACE, + &value); + if(type == LTTV_POINTER) { + after_chunk_trace = (LttvHooks*)*(value.v_pointer); + } + + type = lttv_iattribute_get_by_name(LTTV_IATTRIBUTE(module_attribute), + LTTV_AFTER_CHUNK_TRACEFILE, + &value); + if(type == LTTV_POINTER) { + after_chunk_tracefile = (LttvHooks*)*(value.v_pointer); + } + + type = lttv_iattribute_get_by_name(LTTV_IATTRIBUTE(module_attribute), + LTTV_EVENT_HOOK, + &value); + if(type == LTTV_POINTER) { + event_hook = (LttvHooks*)*(value.v_pointer); + } + + type = lttv_iattribute_get_by_name(LTTV_IATTRIBUTE(module_attribute), + LTTV_EVENT_HOOK_BY_ID, + &value); + if(type == LTTV_POINTER) { + event_hook_by_id = (LttvHooksById*)*(value.v_pointer); + } + + lttv_process_traceset_end(tsc, + after_chunk_traceset, + after_chunk_trace, + after_chunk_tracefile, + event_hook, + event_hook_by_id); + + /* Call the module's hook remover */ + type = lttv_iattribute_get_by_name(LTTV_IATTRIBUTE(module_attribute), + LTTV_HOOK_REMOVER, + &value); + if(type == LTTV_POINTER) { + lttv_hooks_call((LttvHooks*)*(value.v_pointer), (gpointer)tss); + } +} + + +void lttvwindowtraces_set_in_progress(LttvAttributeName module_name, + LttvTrace *trace) +{ + LttvAttribute *attribute = lttv_trace_attribute(trace); + LttvAttributeValue value; + + g_assert(attribute = + LTTV_ATTRIBUTE(lttv_iattribute_find_subdir(LTTV_IATTRIBUTE(attribute), + module_name))); + + value = lttv_iattribute_add(LTTV_IATTRIBUTE(attribute), + LTTV_IN_PROGRESS, + LTTV_INT); + /* the value is left unset. The only presence of the attribute is necessary. + */ +} + +void lttvwindowtraces_unset_in_progress(LttvAttributeName module_name, + LttvTrace *trace) +{ + LttvAttribute *attribute = lttv_trace_attribute(trace); + + g_assert(attribute = + LTTV_ATTRIBUTE(lttv_iattribute_find_subdir(LTTV_IATTRIBUTE(attribute), + module_name))); + + lttv_iattribute_remove_by_name(LTTV_IATTRIBUTE(attribute), + LTTV_IN_PROGRESS); +} + +gboolean lttvwindowtraces_get_in_progress(LttvAttributeName module_name, + LttvTrace *trace) +{ + LttvAttribute *attribute = lttv_trace_attribute(trace); + LttvAttributeType type; + LttvAttributeValue value; + + g_assert(attribute = + LTTV_ATTRIBUTE(lttv_iattribute_find_subdir(LTTV_IATTRIBUTE(attribute), + module_name))); + + type = lttv_iattribute_get_by_name(LTTV_IATTRIBUTE(attribute), + LTTV_IN_PROGRESS, + &value); + /* The only presence of the attribute is necessary. */ + if(type == LTTV_NONE) + return FALSE; + else + return TRUE; +} + +void lttvwindowtraces_set_ready(LttvAttributeName module_name, + LttvTrace *trace) +{ + LttvAttribute *attribute = lttv_trace_attribute(trace); + LttvAttributeValue value; + + g_assert(attribute = + LTTV_ATTRIBUTE(lttv_iattribute_find_subdir(LTTV_IATTRIBUTE(attribute), + module_name))); + + value = lttv_iattribute_add(LTTV_IATTRIBUTE(attribute), + LTTV_READY, + LTTV_INT); + /* the value is left unset. The only presence of the attribute is necessary. + */ +} + +void lttvwindowtraces_unset_ready(LttvAttributeName module_name, + LttvTrace *trace) +{ + LttvAttribute *attribute = lttv_trace_attribute(trace); + + g_assert(attribute = + LTTV_ATTRIBUTE(lttv_iattribute_find_subdir(LTTV_IATTRIBUTE(attribute), + module_name))); + + lttv_iattribute_remove_by_name(LTTV_IATTRIBUTE(attribute), + LTTV_READY); +} + +gboolean lttvwindowtraces_get_ready(LttvAttributeName module_name, + LttvTrace *trace) +{ + LttvAttribute *attribute = lttv_trace_attribute(trace); + LttvAttributeType type; + LttvAttributeValue value; + + g_assert(attribute = + LTTV_ATTRIBUTE(lttv_iattribute_find_subdir(LTTV_IATTRIBUTE(attribute), + module_name))); + + type = lttv_iattribute_get_by_name(LTTV_IATTRIBUTE(attribute), + LTTV_READY, + &value); + /* The only presence of the attribute is necessary. */ + if(type == LTTV_NONE) + return FALSE; + else + return TRUE; +} + + + +/* lttvwindowtraces_process_pending_requests + * + * This internal function gets called by g_idle, taking care of the pending + * requests. + * + */ + + +gboolean lttvwindowtraces_process_pending_requests(LttvTrace *trace) +{ + LttvTracesetContext *tsc; + LttvTracesetStats *tss; + LttvTraceset *ts; + LttvAttribute *attribute; + GSList **list_out, **list_in, **notify_in, **notify_out; + LttvAttributeValue value; + LttvAttributeType type; + + if(trace == NULL) + return FALSE; + + attribute = lttv_trace_attribute(trace); + + type = lttv_iattribute_get_by_name(LTTV_IATTRIBUTE(attribute), + LTTV_REQUESTS_QUEUE, + &value); + g_assert(type == LTTV_POINTER); + list_out = (GSList**)(value.v_pointer); + + type = lttv_iattribute_get_by_name(LTTV_IATTRIBUTE(attribute), + LTTV_REQUESTS_CURRENT, + &value); + g_assert(type == LTTV_POINTER); + list_in = (GSList**)(value.v_pointer); + + type = lttv_iattribute_get_by_name(LTTV_IATTRIBUTE(attribute), + LTTV_NOTIFY_QUEUE, + &value); + g_assert(type == LTTV_POINTER); + notify_out = (GSList**)(value.v_pointer); + + type = lttv_iattribute_get_by_name(LTTV_IATTRIBUTE(attribute), + LTTV_NOTIFY_CURRENT, + &value); + g_assert(type == LTTV_POINTER); + notify_in = (GSList**)(value.v_pointer); + + type = lttv_iattribute_get_by_name(LTTV_IATTRIBUTE(attribute), + LTTV_COMPUTATION_TRACESET, + &value); + g_assert(type == LTTV_POINTER); + ts = (LttvTraceset*)*(value.v_pointer); + + type = lttv_iattribute_get_by_name(LTTV_IATTRIBUTE(attribute), + LTTV_COMPUTATION_TRACESET_CONTEXT, + &value); + g_assert(type == LTTV_POINTER); + tsc = (LttvTracesetContext*)*(value.v_pointer); + tss = (LttvTracesetStats*)*(value.v_pointer); + g_assert(LTTV_IS_TRACESET_CONTEXT(tsc)); + g_assert(LTTV_IS_TRACESET_STATS(tss)); + + /* There is no events requests pending : we should never have been called! */ + g_assert(g_slist_length(*list_out) != 0 || g_slist_length(*list_in) != 0); + + + + /* 1. Before processing */ + { + /* if list_in is empty */ + if(g_slist_length(*list_in) == 0) { + + { + /* - Add all requests in list_out to list_in, empty list_out */ + GSList *iter = *list_out; + + while(iter != NULL) { + gboolean remove = FALSE; + gboolean free_data = FALSE; + + BackgroundRequest *bg_req = (BackgroundRequest*)iter->data; + + remove = TRUE; + free_data = FALSE; + *list_in = g_slist_append(*list_in, bg_req); + + /* Go to next */ + if(remove) + { + GSList *remove_iter = iter; + + iter = g_slist_next(iter); + if(free_data) g_free(remove_iter->data); + *list_out = g_slist_remove_link(*list_out, remove_iter); + } else { // not remove + iter = g_slist_next(iter); + } + } + } + + { + GSList *iter = *list_in; + /* - for each request in list_in */ + while(iter != NULL) { + + BackgroundRequest *bg_req = (BackgroundRequest*)iter->data; + /*- add hooks to context*/ + lttvwindowtraces_set_in_progress(bg_req->module_name, + bg_req->trace); + + iter = g_slist_next(iter); + } + } + + /* - seek trace to start */ + { + LttTime start = { 0, 0}; + lttv_process_traceset_seek_time(tsc, start); + } + + /* - Move all notifications from notify_out to notify_in. */ + { + GSList *iter = *notify_out; + g_assert(g_slist_length(*notify_in) == 0); + + while(iter != NULL) { + gboolean remove = FALSE; + gboolean free_data = FALSE; + + BackgroundNotify *notify_req = (BackgroundNotify*)iter->data; + + remove = TRUE; + free_data = FALSE; + *notify_in = g_slist_append(*notify_in, notify_req); + + /* Go to next */ + if(remove) + { + GSList *remove_iter = iter; + + iter = g_slist_next(iter); + if(free_data) g_free(remove_iter->data); + *notify_out = g_slist_remove_link(*notify_out, remove_iter); + } else { // not remove + iter = g_slist_next(iter); + } + } + } + } + + { + GSList *iter = *list_in; + /* - for each request in list_in */ + while(iter != NULL) { + + BackgroundRequest *bg_req = (BackgroundRequest*)iter->data; + /*- Call before chunk hooks for list_in*/ + /*- add hooks to context*/ + lttvwindowtraces_add_computation_hooks(bg_req->module_name, + tsc); + iter = g_slist_next(iter); + } + } + } + + /* 2. call process traceset middle for a chunk */ + { + /*(assert list_in is not empty! : should not even be called in that case)*/ + LttTime end = { G_MAXUINT, G_MAXUINT }; + g_assert(g_slist_length(*list_in) != 0); + + lttv_process_traceset_middle(tsc, end, CHUNK_NUM_EVENTS, NULL); + } + + /* 3. After the chunk */ + { + /* 3.1 call after_chunk hooks for list_in */ + { + GSList *iter = *list_in; + /* - for each request in list_in */ + while(iter != NULL) { + + BackgroundRequest *bg_req = (BackgroundRequest*)iter->data; + /* - Call after chunk hooks for list_in */ + /* - remove hooks from context */ + lttvwindowtraces_remove_computation_hooks(bg_req->module_name, + tsc); + iter = g_slist_next(iter); + } + } + + /* 3.2 for each notify_in */ + { + GSList *iter = *notify_in; + LttvTracefileContext *tfc = lttv_traceset_context_get_current_tfc(tsc); + + while(iter != NULL) { + gboolean remove = FALSE; + gboolean free_data = FALSE; + + BackgroundNotify *notify_req = (BackgroundNotify*)iter->data; + + /* - if current time >= notify time, call notify and remove from + * notify_in. + * - if current position >= notify position, call notify and remove + * from notify_in. + */ + if( (tfc != NULL && + ltt_time_compare(notify_req->notify_time, tfc->timestamp) <= 0) + || + (notify_req->notify_position != NULL && + lttv_traceset_context_ctx_pos_compare(tsc, + notify_req->notify_position) >= 0) + ) { + + lttv_hooks_call(notify_req->notify, notify_req); + + remove = TRUE; + free_data = TRUE; + } + + /* Go to next */ + if(remove) + { + GSList *remove_iter = iter; + + iter = g_slist_next(iter); + if(free_data) g_free(remove_iter->data); + *notify_in = g_slist_remove_link(*notify_in, remove_iter); + } else { // not remove + iter = g_slist_next(iter); + } + } + } + + { + LttvTracefileContext *tfc = lttv_traceset_context_get_current_tfc(tsc); + /* 3.3 if end of trace reached */ + if(tfc != NULL) + g_debug("Current time : %lu sec, %lu nsec", + tfc->timestamp.tv_sec, tfc->timestamp.tv_nsec); + if(tfc == NULL || ltt_time_compare(tfc->timestamp, + tsc->time_span.end_time) > 0) { + + /* - for each request in list_in */ + { + GSList *iter = *list_in; + + while(iter != NULL) { + gboolean remove = FALSE; + gboolean free_data = FALSE; + + BackgroundRequest *bg_req = (BackgroundRequest*)iter->data; + + /* - set hooks'in_progress flag to FALSE */ + lttvwindowtraces_unset_in_progress(bg_req->module_name, + bg_req->trace); + /* - set hooks'ready flag to TRUE */ + lttvwindowtraces_set_ready(bg_req->module_name, + bg_req->trace); + /* - remove request */ + remove = TRUE; + free_data = TRUE; + + /* Go to next */ + if(remove) + { + GSList *remove_iter = iter; + + iter = g_slist_next(iter); + if(free_data) g_free(remove_iter->data); + *list_in = g_slist_remove_link(*list_in, remove_iter); + } else { // not remove + iter = g_slist_next(iter); + } + } + } + + /* - for each notifications in notify_in */ + { + GSList *iter = *notify_in; + + while(iter != NULL) { + gboolean remove = FALSE; + gboolean free_data = FALSE; + + BackgroundNotify *notify_req = (BackgroundNotify*)iter->data; + + /* - call notify and remove from notify_in */ + lttv_hooks_call(notify_req->notify, notify_req); + remove = TRUE; + free_data = TRUE; + + /* Go to next */ + if(remove) + { + GSList *remove_iter = iter; + + iter = g_slist_next(iter); + if(free_data) g_free(remove_iter->data); + *notify_in = g_slist_remove_link(*notify_in, remove_iter); + } else { // not remove + iter = g_slist_next(iter); + } + } + } + + /* - return FALSE (scheduler stopped) */ + g_debug("Background computation scheduler stopped"); + return FALSE; + } else { + /* 3.4 else, end of trace not reached */ + /* - return TRUE (scheduler still registered) */ + g_debug("Background computation left"); + return TRUE; + } + } + } +} + + + +/** + * Register the background computation hooks for a specific module. It adds the + * computation hooks to the global attrubutes, under "computation/module name". + * + * @param module_name A GQuark : the name of the module which computes the + * information. + */ +void lttvwindowtraces_register_computation_hooks(LttvAttributeName module_name, + LttvHooks *before_chunk_traceset, + LttvHooks *before_chunk_trace, + LttvHooks *before_chunk_tracefile, + LttvHooks *after_chunk_traceset, + LttvHooks *after_chunk_trace, + LttvHooks *after_chunk_tracefile, + LttvHooks *before_request, + LttvHooks *after_request, + LttvHooks *event_hook, + LttvHooksById *event_hook_by_id, + LttvHooks *hook_adder, + LttvHooks *hook_remover) +{ + LttvAttribute *g_attribute = lttv_global_attributes(); + LttvAttribute *attribute; + LttvAttributeValue value; + + g_assert(attribute = + LTTV_ATTRIBUTE(lttv_iattribute_find_subdir(LTTV_IATTRIBUTE(g_attribute), + LTTV_COMPUTATION))); + + g_assert(attribute = + LTTV_ATTRIBUTE(lttv_iattribute_find_subdir(LTTV_IATTRIBUTE(attribute), + module_name))); + + g_assert(lttv_iattribute_find(LTTV_IATTRIBUTE(attribute), + LTTV_BEFORE_CHUNK_TRACESET, + LTTV_POINTER, + &value)); + *(value.v_pointer) = before_chunk_traceset; + + g_assert(lttv_iattribute_find(LTTV_IATTRIBUTE(attribute), + LTTV_BEFORE_CHUNK_TRACE, + LTTV_POINTER, + &value)); + *(value.v_pointer) = before_chunk_trace; + + g_assert(lttv_iattribute_find(LTTV_IATTRIBUTE(attribute), + LTTV_BEFORE_CHUNK_TRACEFILE, + LTTV_POINTER, + &value)); + *(value.v_pointer) = before_chunk_tracefile; + + g_assert(lttv_iattribute_find(LTTV_IATTRIBUTE(attribute), + LTTV_AFTER_CHUNK_TRACESET, + LTTV_POINTER, + &value)); + *(value.v_pointer) = after_chunk_traceset; + + g_assert(lttv_iattribute_find(LTTV_IATTRIBUTE(attribute), + LTTV_AFTER_CHUNK_TRACE, + LTTV_POINTER, + &value)); + *(value.v_pointer) = after_chunk_trace; + + g_assert(lttv_iattribute_find(LTTV_IATTRIBUTE(attribute), + LTTV_AFTER_CHUNK_TRACEFILE, + LTTV_POINTER, + &value)); + *(value.v_pointer) = after_chunk_tracefile; + + g_assert(lttv_iattribute_find(LTTV_IATTRIBUTE(attribute), + LTTV_BEFORE_REQUEST, + LTTV_POINTER, + &value)); + *(value.v_pointer) = before_request; + + g_assert(lttv_iattribute_find(LTTV_IATTRIBUTE(attribute), + LTTV_AFTER_REQUEST, + LTTV_POINTER, + &value)); + *(value.v_pointer) = after_request; + + g_assert(lttv_iattribute_find(LTTV_IATTRIBUTE(attribute), + LTTV_EVENT_HOOK, + LTTV_POINTER, + &value)); + *(value.v_pointer) = event_hook; + + g_assert(lttv_iattribute_find(LTTV_IATTRIBUTE(attribute), + LTTV_EVENT_HOOK_BY_ID, + LTTV_POINTER, + &value)); + *(value.v_pointer) = event_hook_by_id; + + g_assert(lttv_iattribute_find(LTTV_IATTRIBUTE(attribute), + LTTV_HOOK_ADDER, + LTTV_POINTER, + &value)); + *(value.v_pointer) = hook_adder; + + g_assert(lttv_iattribute_find(LTTV_IATTRIBUTE(attribute), + LTTV_HOOK_REMOVER, + LTTV_POINTER, + &value)); + *(value.v_pointer) = hook_remover; + +} + + +/** + * It removes all the requests than can be currently processed by the + * background computation algorithm for all the traces (list_in and list_out). + * + * Leaves the flag to in_progress or none.. depending if current or queue + * + * @param module_name A GQuark : the name of the module which computes the + * information. + */ +void lttvwindowtraces_unregister_requests(LttvAttributeName module_name) +{ + guint i; + + for(i=0;idata; + + if(bg_req->module_name == module_name) { + remove = TRUE; + free_data = TRUE; + } + + /* Go to next */ + if(remove) + { + GSList *remove_iter = iter; + + iter = g_slist_next(iter); + if(free_data) g_free(remove_iter->data); + *queue = g_slist_remove_link(*queue, remove_iter); + } else { // not remove + iter = g_slist_next(iter); + } + } + + + g_assert(lttv_iattribute_find(LTTV_IATTRIBUTE(attribute), + LTTV_REQUESTS_CURRENT, + LTTV_POINTER, + &value)); + current = (GSList**)(value.v_pointer); + + iter = *current; + while(iter != NULL) { + gboolean remove = FALSE; + gboolean free_data = FALSE; + + BackgroundRequest *bg_req = (BackgroundRequest*)iter->data; + + if(bg_req->module_name == module_name) { + remove = TRUE; + free_data = TRUE; + } + + /* Go to next */ + if(remove) + { + GSList *remove_iter = iter; + + iter = g_slist_next(iter); + if(free_data) g_free(remove_iter->data); + *current = g_slist_remove_link(*current, remove_iter); + } else { // not remove + iter = g_slist_next(iter); + } + } + } +} + + +/** + * Unregister the background computation hooks for a specific module. + * + * It also removes all the requests than can be currently processed by the + * background computation algorithm for all the traces (list_in and list_out). + * + * @param module_name A GQuark : the name of the module which computes the + * information. + */ + +void lttvwindowtraces_unregister_computation_hooks + (LttvAttributeName module_name) +{ + LttvAttribute *g_attribute = lttv_global_attributes(); + LttvAttribute *attribute; + + g_assert(attribute = + LTTV_ATTRIBUTE(lttv_iattribute_find_subdir(LTTV_IATTRIBUTE(g_attribute), + LTTV_COMPUTATION))); + g_assert(attribute = + LTTV_ATTRIBUTE(lttv_iattribute_find_subdir(LTTV_IATTRIBUTE(attribute), + module_name))); + + + lttv_iattribute_remove_by_name(LTTV_IATTRIBUTE(attribute), + LTTV_EVENT_HOOK_BY_ID); + lttv_iattribute_remove_by_name(LTTV_IATTRIBUTE(attribute), + LTTV_EVENT_HOOK); + + lttv_iattribute_remove_by_name(LTTV_IATTRIBUTE(attribute), + LTTV_AFTER_REQUEST); + lttv_iattribute_remove_by_name(LTTV_IATTRIBUTE(attribute), + LTTV_BEFORE_REQUEST); + + lttv_iattribute_remove_by_name(LTTV_IATTRIBUTE(attribute), + LTTV_AFTER_CHUNK_TRACEFILE); + lttv_iattribute_remove_by_name(LTTV_IATTRIBUTE(attribute), + LTTV_AFTER_CHUNK_TRACE); + lttv_iattribute_remove_by_name(LTTV_IATTRIBUTE(attribute), + LTTV_AFTER_CHUNK_TRACESET); + + lttv_iattribute_remove_by_name(LTTV_IATTRIBUTE(attribute), + LTTV_BEFORE_CHUNK_TRACEFILE); + lttv_iattribute_remove_by_name(LTTV_IATTRIBUTE(attribute), + LTTV_BEFORE_CHUNK_TRACE); + lttv_iattribute_remove_by_name(LTTV_IATTRIBUTE(attribute), + LTTV_BEFORE_CHUNK_TRACESET); + lttv_iattribute_remove_by_name(LTTV_IATTRIBUTE(attribute), + LTTV_HOOK_ADDER); + lttv_iattribute_remove_by_name(LTTV_IATTRIBUTE(attribute), + LTTV_HOOK_REMOVER); + + /* finally, remove module name */ + g_assert(attribute = + LTTV_ATTRIBUTE(lttv_iattribute_find_subdir(LTTV_IATTRIBUTE(g_attribute), + LTTV_COMPUTATION))); + lttv_iattribute_remove_by_name(LTTV_IATTRIBUTE(attribute), + module_name); + +} + +