/* Here is the implementation of the API */
+#ifdef HAVE_CONFIG_H
+#include <config.h>
+#endif
+
#include <sys/types.h>
#include <sys/stat.h>
#include <unistd.h>
+#include <string.h>
#include <ltt/time.h>
#include <ltt/trace.h>
#include <lttv/tracecontext.h>
#include <lttvwindow/lttvwindowtraces.h>
#include <lttvwindow/lttvwindow.h> // for CHUNK_NUM_EVENTS
+#include <lttvwindow/mainwindow-private.h> /* for main window structure */
+extern GSList * g_main_window_list;
typedef struct _BackgroundRequest {
LttvAttributeName module_name; /* Hook path in global attributes,
where all standard hooks under computation/.
i.e. modulename */
LttvTrace *trace; /* trace concerned */
+ GtkWidget *dialog; /* Dialog linked with the request, may be NULL */
+ GtkWidget *parent_window; /* Parent window the dialog must be transient for */
} BackgroundRequest;
typedef struct _BackgroundNotify {
LttvTrace *lttvwindowtraces_get_trace_by_name(gchar *path)
{
- LttvAttribute *attribute = lttv_global_attributes();
guint i;
for(i=0;i<lttvwindowtraces_get_number();i++) {
trace = lttv_trace(trace_v);
g_assert(trace != NULL);
- name = ltt_trace_name(trace);
+ name = g_quark_to_string(ltt_trace_name(trace));
if(strcmp(name, path) == 0) {
/* Found */
struct stat buf;
gchar attribute_path[PATH_MAX];
- if(stat(ltt_trace_name(lttv_trace(trace)), &buf)) {
+ if(stat(g_quark_to_string(ltt_trace_name(lttv_trace(trace))), &buf)) {
g_warning("lttvwindowtraces_add_trace: Trace %s not found",
- ltt_trace_name(lttv_trace(trace)));
+ g_quark_to_string(ltt_trace_name(lttv_trace(trace))));
return;
}
g_assert(
- snprintf(attribute_path, PATH_MAX, "%lu:%lu", buf.st_dev, buf.st_ino) >= 0);
+ snprintf(attribute_path, PATH_MAX, "%llu:%llu", buf.st_dev, buf.st_ino) >= 0);
g_assert(attribute =
LTTV_ATTRIBUTE(lttv_iattribute_find_subdir(LTTV_IATTRIBUTE(g_attribute),
/* create new traceset and tracesetcontext */
LttvTraceset *ts;
LttvTracesetStats *tss;
+ //LttvTracesetContextPosition *sync_position;
attribute = lttv_trace_attribute(trace);
g_assert(lttv_iattribute_find(LTTV_IATTRIBUTE(attribute),
*(value.v_pointer) = tss;
lttv_context_init(LTTV_TRACESET_CONTEXT(tss), ts);
+#if 0
+ g_assert(lttv_iattribute_find(LTTV_IATTRIBUTE(attribute),
+ LTTV_COMPUTATION_SYNC_POSITION,
+ LTTV_POINTER,
+ &value));
+ sync_position = lttv_traceset_context_position_new();
+ *(value.v_pointer) = sync_position;
+#endif //0
value = lttv_attribute_add(attribute,
LTTV_REQUESTS_QUEUE,
LTTV_POINTER);
/* Found */
LttvAttribute *l_attribute;
- /* create new traceset and tracesetcontext */
+ /* destroy traceset and tracesetcontext */
LttvTraceset *ts;
LttvTracesetStats *tss;
+ //LttvTracesetContextPosition *sync_position;
l_attribute = lttv_trace_attribute(trace);
LTTV_POINTER,
&value));
ts = (LttvTraceset*)*(value.v_pointer);
-
+#if 0
+ g_assert(lttv_iattribute_find(LTTV_IATTRIBUTE(l_attribute),
+ LTTV_COMPUTATION_SYNC_POSITION,
+ LTTV_POINTER,
+ &value));
+ sync_position = (LttvTracesetContextPosition*)*(value.v_pointer);
+ lttv_traceset_context_position_destroy(sync_position);
+
+ lttv_iattribute_remove_by_name(LTTV_IATTRIBUTE(l_attribute),
+ LTTV_COMPUTATION_SYNC_POSITION);
+
+#endif //0
g_assert(lttv_iattribute_find(LTTV_IATTRIBUTE(l_attribute),
LTTV_COMPUTATION_TRACESET_CONTEXT,
LTTV_POINTER,
}
}
+static void destroy_dialog(BackgroundRequest *bg_req)
+{
+ gtk_widget_destroy(bg_req->dialog);
+ bg_req->dialog = NULL;
+}
+
/**
* Function to request data from a specific trace
*
* The memory allocated for the request will be managed by the API.
*
+ * @param widget the current Window
* @param trace the trace to compute
* @param module_name the name of the module which registered global computation
* hooks.
*/
void lttvwindowtraces_background_request_queue
- (LttvTrace *trace, gchar *module_name)
+ (GtkWidget *widget, LttvTrace *trace, gchar *module_name)
{
BackgroundRequest *bg_req;
LttvAttribute *attribute = lttv_trace_attribute(trace);
trace,
NULL);
/* FIXME : show message in status bar, need context and message id */
- g_info("Background computation started for trace %p", trace);
+ g_info("Background computation for %s started for trace %p", module_name,
+ trace);
+ GtkWidget *dialog =
+ gtk_message_dialog_new(
+ GTK_WINDOW(widget),
+ GTK_DIALOG_DESTROY_WITH_PARENT,
+ GTK_MESSAGE_INFO, GTK_BUTTONS_OK,
+ "Background computation for %s started for trace %s",
+ module_name,
+ g_quark_to_string(ltt_trace_name(lttv_trace(trace))));
+ gtk_window_set_transient_for(GTK_WINDOW(dialog), GTK_WINDOW(widget));
+ g_signal_connect_swapped (dialog, "response",
+ G_CALLBACK (destroy_dialog),
+ bg_req);
+ bg_req->dialog = dialog;
+ /* the parent window might vanish : only use this pointer for a
+ * comparison with existing windows */
+ bg_req->parent_window = gtk_widget_get_toplevel(widget);
+ gtk_widget_show(dialog);
}
/**
}
}
+/**
+ * Find a background request in a trace
+ *
+ */
+
+gboolean lttvwindowtraces_background_request_find
+ (LttvTrace *trace, gchar *module_name)
+{
+ LttvAttribute *attribute = lttv_trace_attribute(trace);
+ LttvAttributeValue value;
+ GSList *iter = NULL;
+ GSList **slist;
+
+ g_assert(lttv_iattribute_find(LTTV_IATTRIBUTE(attribute),
+ LTTV_REQUESTS_QUEUE,
+ LTTV_POINTER,
+ &value));
+ slist = (GSList**)(value.v_pointer);
+
+ for(iter=*slist;iter!=NULL;) {
+ BackgroundRequest *bg_req =
+ (BackgroundRequest *)iter->data;
+
+ if(bg_req->module_name == g_quark_from_string(module_name)) {
+ return TRUE;
+ } else {
+ iter=g_slist_next(iter);
+ }
+ }
+ return FALSE;
+}
/**
* Register a callback to be called when requested data is passed in the next
&value));
slist = (GSList**)(value.v_pointer);
+ g_assert(lttv_iattribute_find(LTTV_IATTRIBUTE(attribute),
+ LTTV_COMPUTATION_TRACESET_CONTEXT,
+ LTTV_POINTER,
+ &value));
+ LttvTracesetContext *tsc = (LttvTracesetContext*)(value.v_pointer);
bg_notify = g_new(BackgroundNotify,1);
bg_notify->trace = trace;
bg_notify->notify_time = notify_time;
if(notify_position != NULL) {
- bg_notify->notify_position = lttv_traceset_context_position_new();
+ bg_notify->notify_position = lttv_traceset_context_position_new(tsc);
lttv_traceset_context_position_copy(bg_notify->notify_position,
notify_position);
} else {
&value));
slist = (GSList**)(value.v_pointer);
+ g_assert(lttv_iattribute_find(LTTV_IATTRIBUTE(attribute),
+ LTTV_COMPUTATION_TRACESET_CONTEXT,
+ LTTV_POINTER,
+ &value));
+ LttvTracesetContext *tsc = (LttvTracesetContext*)(value.v_pointer);
+
+
bg_notify = g_new(BackgroundNotify,1);
bg_notify->owner = owner;
bg_notify->trace = trace;
bg_notify->notify_time = notify_time;
if(notify_position!= NULL) {
- bg_notify->notify_position = lttv_traceset_context_position_new();
+ bg_notify->notify_position = lttv_traceset_context_position_new(tsc);
lttv_traceset_context_position_copy(bg_notify->notify_position,
notify_position);
} else {
LttvAttribute *module_attribute;
LttvAttributeType type;
LttvAttributeValue value;
+
+
+ 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)));
+
+ /* 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);
+ if(hook_adder != NULL)
+ lttv_hooks_add_list(hook_adder, (LttvHooks*)*(value.v_pointer));
+ }
+}
+
+void lttvwindowtraces_remove_computation_hooks(LttvAttributeName module_name,
+ LttvTracesetContext *tsc,
+ LttvHooks *hook_remover)
+{
+ LttvAttribute *g_attribute = lttv_global_attributes();
+ LttvAttribute *module_attribute;
+ LttvAttributeType type;
+ LttvAttributeValue value;
+
+ 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)));
+
+ /* 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);
+ if(hook_remover != NULL)
+ lttv_hooks_add_list(hook_remover, (LttvHooks*)*(value.v_pointer));
+ }
+}
+
+void lttvwindowtraces_call_before_chunk(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;
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);
- if(hook_adder != NULL)
- lttv_hooks_add_list(hook_adder, (LttvHooks*)*(value.v_pointer));
- }
-
-
-
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,
- LttvHooks *hook_remover)
+
+
+
+void lttvwindowtraces_call_after_chunk(LttvAttributeName module_name,
+ LttvTracesetContext *tsc)
{
LttvAttribute *g_attribute = lttv_global_attributes();
LttvAttribute *module_attribute;
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);
- if(hook_remover != NULL)
- lttv_hooks_add_list(hook_remover, (LttvHooks*)*(value.v_pointer));
- }
}
return TRUE;
}
+static gint find_window_widget(MainWindow *a, GtkWidget *b)
+{
+ if(a->mwindow == b) return 0;
+ else return -1;
+}
+
/* lttvwindowtraces_process_pending_requests
*
LttvTracesetContext *tsc;
LttvTracesetStats *tss;
LttvTraceset *ts;
+ //LttvTracesetContextPosition *sync_position;
LttvAttribute *attribute;
LttvAttribute *g_attribute = lttv_global_attributes();
GSList **list_out, **list_in, **notify_in, **notify_out;
LttvAttributeValue value;
LttvAttributeType type;
gboolean ret_val;
- LttvHooks *before_request, *after_request;
if(trace == NULL)
return FALSE;
tss = (LttvTracesetStats*)*(value.v_pointer);
g_assert(LTTV_IS_TRACESET_CONTEXT(tsc));
g_assert(LTTV_IS_TRACESET_STATS(tss));
-
+#if 0
+ type = lttv_iattribute_get_by_name(LTTV_IATTRIBUTE(attribute),
+ LTTV_COMPUTATION_SYNC_POSITION,
+ &value);
+ g_assert(type == LTTV_POINTER);
+ sync_position = (LttvTracesetContextPosition*)*(value.v_pointer);
+#endif //0
/* 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);
-
/* 0.1 Lock traces */
{
guint iter_trace=0;
}
}
/* 0.2 Sync tracefiles */
+ //g_assert(lttv_process_traceset_seek_position(tsc, sync_position) == 0);
lttv_process_traceset_synchronize_tracefiles(tsc);
-
/* 1. Before processing */
{
/* if list_in is empty */
&value);
g_assert(type == LTTV_POINTER);
LttvHooks *before_request = (LttvHooks*)*(value.v_pointer);
-
if(before_request != NULL) lttv_hooks_call(before_request, tsc);
}
}
}
+ {
+ GSList *iter = *list_in;
+ LttvHooks *hook_adder = lttv_hooks_new();
+ /* - for each request in list_in */
+ while(iter != NULL) {
+
+ BackgroundRequest *bg_req = (BackgroundRequest*)iter->data;
+ /*- add hooks to context*/
+ lttvwindowtraces_add_computation_hooks(bg_req->module_name,
+ tsc,
+ hook_adder);
+ iter = g_slist_next(iter);
+ }
+ lttv_hooks_call(hook_adder,tsc);
+ lttv_hooks_destroy(hook_adder);
+ }
+
+
}
{
GSList *iter = *list_in;
- LttvHooks *hook_adder = lttv_hooks_new();
/* - 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,
- hook_adder);
+ lttvwindowtraces_call_before_chunk(bg_req->module_name,
+ tsc);
iter = g_slist_next(iter);
}
- lttv_hooks_call(hook_adder,tsc);
- lttv_hooks_destroy(hook_adder);
}
- }
+ }
/* 2. call process traceset middle for a chunk */
{
/*(assert list_in is not empty! : should not even be called in that case)*/
/* 3.1 call after_chunk hooks for list_in */
{
GSList *iter = *list_in;
- LttvHooks *hook_remover = lttv_hooks_new();
/* - 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,
- hook_remover);
+ lttvwindowtraces_call_after_chunk(bg_req->module_name,
+ tsc);
iter = g_slist_next(iter);
}
- lttv_hooks_call(hook_remover,tsc);
- lttv_hooks_destroy(hook_remover);
}
/* 3.2 for each notify_in */
tfc->timestamp.tv_sec, tfc->timestamp.tv_nsec);
if(tfc == NULL || ltt_time_compare(tfc->timestamp,
tsc->time_span.end_time) > 0) {
-
+
+ {
+ GSList *iter = *list_in;
+ LttvHooks *hook_remover = lttv_hooks_new();
+ /* - for each request in list_in */
+ while(iter != NULL) {
+
+ BackgroundRequest *bg_req = (BackgroundRequest*)iter->data;
+ /* - remove hooks from context */
+ lttvwindowtraces_remove_computation_hooks(bg_req->module_name,
+ tsc,
+ hook_remover);
+ iter = g_slist_next(iter);
+ }
+ lttv_hooks_call(hook_remover,tsc);
+ lttv_hooks_destroy(hook_remover);
+ }
+
/* - for each request in list_in */
{
GSList *iter = *list_in;
LttvHooks *after_request = (LttvHooks*)*(value.v_pointer);
if(after_request != NULL) lttv_hooks_call(after_request, tsc);
+
+ if(bg_req->dialog != NULL)
+ gtk_widget_destroy(bg_req->dialog);
+ GtkWidget *parent_window;
+ if(g_slist_find_custom(g_main_window_list,
+ bg_req->parent_window,
+ (GCompareFunc)find_window_widget))
+ parent_window = GTK_WIDGET(bg_req->parent_window);
+ else
+ parent_window = NULL;
+
+ GtkWidget *dialog =
+ gtk_message_dialog_new(GTK_WINDOW(parent_window),
+ GTK_DIALOG_DESTROY_WITH_PARENT,
+ GTK_MESSAGE_INFO, GTK_BUTTONS_OK,
+ "Background computation %s finished for trace %s",
+ g_quark_to_string(bg_req->module_name),
+ g_quark_to_string(ltt_trace_name(lttv_trace(bg_req->trace))));
+ if(parent_window != NULL)
+ gtk_window_set_transient_for(GTK_WINDOW(dialog),
+ GTK_WINDOW(parent_window));
+ g_signal_connect_swapped (dialog, "response",
+ G_CALLBACK (gtk_widget_destroy),
+ dialog);
+ gtk_widget_show(dialog);
+
/* - remove request */
remove = TRUE;
free_data = TRUE;
g_debug("Background computation scheduler stopped");
g_info("Background computation finished for trace %p", trace);
/* FIXME : remove status bar info, need context id and message id */
+
ret_val = FALSE;
} else {
ret_val = TRUE;
}
/* 4. Unlock traces */
{
- //lttv_process_traceset_get_sync_data(tsc);
+ lttv_process_traceset_get_sync_data(tsc);
+ //lttv_traceset_context_position_save(tsc, sync_position);
guint iter_trace;
for(iter_trace=0;
projects / lttv.git / blobdiff