X-Git-Url: http://git.liburcu.org/?a=blobdiff_plain;f=lttv%2Flttv%2Ftraceset.c;h=ae7c1a16cecf5e9319813d57a0fecbdf91dfb79e;hb=9aaa78dc9323698c4c44e5aaa24322d0c9e26dab;hp=35c84395af6678aa54356876ec5c3aef9097ffb9;hpb=3685e022fa515d5d17a4b8a81fa596408d0cd4ab;p=lttv.git diff --git a/lttv/lttv/traceset.c b/lttv/lttv/traceset.c index 35c84395..ae7c1a16 100644 --- a/lttv/lttv/traceset.c +++ b/lttv/lttv/traceset.c @@ -25,13 +25,19 @@ #include #include #include +#include #include -#include +#include #include /* To traverse a tree recursively */ #include #include +/* For the use of realpath*/ +#include +#include +/* For strcpy*/ +#include /* A trace is a sequence of events gathered in the same tracing session. The events may be stored in several tracefiles in the same directory. @@ -53,16 +59,11 @@ LttvTraceset *lttv_traceset_new(void) //TODO remove this when we have really mecanism //s->tmpState = g_new(LttvTraceState *, 1); //lttv_trace_state_init(s->tmpState,0); - begin_pos.type = BT_SEEK_BEGIN; - //s->iter = bt_ctf_iter_create(lttv_traceset_get_context(s), - // &begin_pos, - // NULL); s->iter = 0; s->event_hooks = lttv_hooks_new(); - - - + + s->state_trace_handle_index = g_ptr_array_new(); return s; } @@ -84,6 +85,30 @@ LttvTrace *lttv_trace_new(LttTrace *t) return new_trace; } #endif +/* + * get_absolute_pathname : Return the unique pathname in the system + * + * pathname is the relative path. + * + * abs_pathname is being set to the absolute path. + * + */ +void get_absolute_pathname(const gchar *pathname, gchar * abs_pathname) +{ + abs_pathname[0] = '\0'; + + if (realpath(pathname, abs_pathname) != NULL) + return; + else + { + /* error, return the original path unmodified */ + strcpy(abs_pathname, pathname); + return; + } + return; +} + + /* * lttv_trace_create : Create a trace from a path @@ -118,7 +143,11 @@ static LttvTrace *lttv_trace_create(LttvTraceset *ts, const char *path) new_trace->traceset = ts; new_trace->state = g_new(LttvTraceState,1); lttv_trace_state_init(new_trace->state,new_trace); - ts->tmpState = new_trace->state; + + /* Add the state to the trace_handle to state index */ + g_ptr_array_set_size(ts->state_trace_handle_index,id+1); + g_ptr_array_index(ts->state_trace_handle_index,id) = new_trace->state; + return new_trace; } @@ -150,6 +179,7 @@ LttvTraceset *lttv_traceset_copy(LttvTraceset *s_orig) s = g_new(LttvTraceset, 1); s->filename = NULL; s->traces = g_ptr_array_new(); + s->state_trace_handle_index = g_ptr_array_new(); for(i=0;itraces->len;i++) { trace = g_ptr_array_index(s_orig->traces, i); @@ -157,6 +187,10 @@ LttvTraceset *lttv_traceset_copy(LttvTraceset *s_orig) /* WARNING: this is an alias, not a copy. */ g_ptr_array_add(s->traces, trace); + + g_ptr_array_set_size(s->state_trace_handle_index,trace->id+1); + g_ptr_array_index(s->state_trace_handle_index,trace->id) = trace->state; + } s->context = s_orig->context; bt_context_get(s->context); @@ -230,7 +264,6 @@ void lttv_trace_destroy(LttvTrace *t) g_free(t); } - void lttv_traceset_add(LttvTraceset *s, LttvTrace *t) { t->ref_count++; @@ -239,11 +272,14 @@ void lttv_traceset_add(LttvTraceset *s, LttvTrace *t) int lttv_traceset_add_path(LttvTraceset *ts, char *trace_path) { + FTS *tree; FTSENT *node; char * const paths[2] = { trace_path, NULL }; int ret = -1; - + + gboolean metaFileFound = FALSE; + tree = fts_open(paths, FTS_NOCHDIR | FTS_LOGICAL, 0); if (tree == NULL) { g_warning("Cannot traverse \"%s\" for reading.\n", @@ -294,6 +330,7 @@ int lttv_traceset_add_path(LttvTraceset *ts, char *trace_path) "for reading.", node->fts_accpath, trace_path); goto error; } + metaFileFound = TRUE; } } @@ -303,9 +340,13 @@ error: g_warning("Unable to close tree " "file descriptor : %s.", trace_path); } - return ret; + if(metaFileFound) + return ret; + else + return -1; } + unsigned lttv_traceset_number(LttvTraceset *s) { return s->traces->len; @@ -344,12 +385,6 @@ LttvAttribute *lttv_trace_attribute(LttvTrace *t) return t->a; } -#ifdef BABEL_CLEANUP -LttTrace *lttv_trace(LttvTrace *t) -{ - return t->t; -} -#endif gint lttv_trace_get_id(LttvTrace *t) { @@ -385,19 +420,30 @@ guint lttv_trace_get_num_cpu(LttvTrace *t) LttvTracesetPosition *lttv_traceset_create_position(LttvTraceset *traceset) { -#warning "TODO" - return NULL; + LttvTracesetPosition *traceset_pos; + + traceset_pos = g_new(LttvTracesetPosition, 1); + + /* Check in the new passed */ + if(traceset_pos == NULL) { + return NULL; + } + + traceset_pos->iter = traceset->iter; + traceset_pos->bt_pos = bt_iter_get_pos(bt_ctf_get_iter(traceset->iter)); + + return traceset_pos; } void lttv_traceset_destroy_position(LttvTracesetPosition *traceset_pos) { -#warning "TODO" - return NULL; + bt_iter_free_pos(traceset_pos->bt_pos); + g_free(traceset_pos); } void lttv_traceset_seek_to_position(LttvTracesetPosition *traceset_pos) { -#warning "TODO" + bt_iter_set_pos(traceset_pos->iter, traceset_pos->bt_pos); } guint lttv_traceset_get_cpuid_from_event(LttvEvent *event) @@ -422,6 +468,80 @@ guint lttv_traceset_get_cpuid_from_event(LttvEvent *event) return cpu_id; } } +/* + * lttv_traceset_get_timestamp_begin : returns the minimum timestamp of + * all the traces in the traceset. + * + */ + +guint64 lttv_traceset_get_timestamp_begin(LttvTraceset *traceset) +{ + struct bt_context *bt_ctx; + bt_ctx = lttv_traceset_get_context(traceset); + guint64 timestamp_min = G_MAXUINT64, timestamp_cur = 0; + int i; + int trace_count; + LttvTrace *currentTrace; + trace_count = traceset->traces->len; + if(trace_count == 0) + timestamp_min = 0; + else{ + timestamp_min = G_MAXUINT64; + + for(i = 0; i < trace_count;i++) + { + currentTrace = g_ptr_array_index(traceset->traces,i); + timestamp_cur = bt_trace_handle_get_timestamp_begin(bt_ctx, currentTrace->id); + if(timestamp_cur < timestamp_min) + timestamp_min = timestamp_cur; + } + } + return timestamp_min; +} + +/* + * lttv_traceset_get_timestamp_end: returns the maximum timestamp of + * all the traces in the traceset. + * + */ +guint64 lttv_traceset_get_timestamp_end(LttvTraceset *traceset) +{ + struct bt_context *bt_ctx; + bt_ctx = lttv_traceset_get_context(traceset); + guint64 timestamp_max, timestamp_cur = 0; + int i; + int trace_count; + LttvTrace *currentTrace; + trace_count = traceset->traces->len; + + if(trace_count == 0) + timestamp_max = 1; + else + { + timestamp_max = 0; + for(i =0; i < trace_count;i++) + { + currentTrace = g_ptr_array_index(traceset->traces,i); + timestamp_cur = bt_trace_handle_get_timestamp_end(bt_ctx, currentTrace->id); + if(timestamp_cur > timestamp_max) + timestamp_max = timestamp_cur; + } + } + return timestamp_max; +} + +/* + * lttv_traceset_get_time_span : return a TimeInterval representing the + * minimum timestamp dans le maximum timestamp of the traceset. + * + */ +TimeInterval lttv_traceset_get_time_span(LttvTraceset *ts) +{ + TimeInterval time_span; + time_span.start_time =ltt_time_from_uint64( lttv_traceset_get_timestamp_begin(ts)); + time_span.end_time = ltt_time_from_uint64(lttv_traceset_get_timestamp_end(ts)); + return time_span; +} const char *lttv_traceset_get_name_from_event(LttvEvent *event) {