X-Git-Url: http://git.lttng.org/?a=blobdiff_plain;f=ltt%2Fbranches%2Fpoly%2Flttv%2Flttv%2Ftracecontext.c;h=2c8a33855f0d6427827c567a89a9b1ad23949524;hb=032ba5da50aa4bd57b14a1cc9123a3ff579a7702;hp=6f1e7b58a334665c1f1254cb9204d67c3bbb9c23;hpb=f4b88a7dd49bfb6b88ea579410d7e4b59faaf73c;p=lttv.git diff --git a/ltt/branches/poly/lttv/lttv/tracecontext.c b/ltt/branches/poly/lttv/lttv/tracecontext.c index 6f1e7b58..2c8a3385 100644 --- a/ltt/branches/poly/lttv/lttv/tracecontext.c +++ b/ltt/branches/poly/lttv/lttv/tracecontext.c @@ -21,14 +21,14 @@ #endif #include +#include #include #include -#include #include -#include +#include #include - +#define min(a,b) (((a)<(b))?(a):(b)) gint compare_tracefile(gconstpointer a, gconstpointer b) @@ -52,10 +52,15 @@ gint compare_tracefile(gconstpointer a, gconstpointer b) return comparison; } +typedef struct _LttvTracefileContextPosition { + LttEventPosition *event; + LttvTracefileContext *tfc; + gboolean used; /* Tells if the tfc is at end of traceset position */ +} LttvTracefileContextPosition; + + struct _LttvTracesetContextPosition { - GArray *ep; /* Array of LttEventPosition */ - GArray *tfc; /* Array of corresponding - TracefileContext* */ + GArray *tfcp; /* Array of LttvTracefileContextPosition */ LttTime timestamp; /* Current time at the saved position */ /* If ltt_time_infinite : no position is * set, else, a position is set (may be end @@ -128,6 +133,8 @@ static void lttv_traceset_context_compute_time_span( trace = tc->t; ltt_trace_time_span_get(trace, &s, &e); + tc->time_span.start_time = s; + tc->time_span.end_time = e; if(i==0){ time_span->start_time = s; @@ -162,6 +169,7 @@ static void init_tracefile_context(LttTracefile *tracefile, tfc->event = lttv_hooks_new(); tfc->event_by_id = lttv_hooks_by_id_new(); tfc->a = g_object_new(LTTV_ATTRIBUTE_TYPE, NULL); + tfc->target_pid = -1; } @@ -181,7 +189,6 @@ init(LttvTracesetContext *self, LttvTraceset *ts) self->traces = g_new(LttvTraceContext *, nb_trace); self->a = g_object_new(LTTV_ATTRIBUTE_TYPE, NULL); self->ts_a = lttv_traceset_attribute(ts); - self->sync_position = lttv_traceset_context_position_new(); for(i = 0 ; i < nb_trace ; i++) { tc = LTTV_TRACESET_CONTEXT_GET_CLASS(self)->new_trace_context(self); self->traces[i] = tc; @@ -234,6 +241,7 @@ init(LttvTracesetContext *self, LttvTraceset *ts) #endif //0 } + self->sync_position = lttv_traceset_context_position_new(self); self->pqueue = g_tree_new(compare_tracefile); lttv_process_traceset_seek_time(self, ltt_time_zero); lttv_traceset_context_compute_time_span(self, &self->time_span); @@ -673,7 +681,7 @@ void lttv_process_traceset_begin(LttvTracesetContext *self, } -enum read_state { LAST_NONE, LAST_OK, LAST_EMPTY }; +//enum read_state { LAST_NONE, LAST_OK, LAST_EMPTY }; /* Note : a _middle must be preceded from a _seek or another middle */ guint lttv_process_traceset_middle(LttvTracesetContext *self, @@ -683,8 +691,6 @@ guint lttv_process_traceset_middle(LttvTracesetContext *self, { GTree *pqueue = self->pqueue; - guint fac_id, ev_id, id; - LttvTracefileContext *tfc; LttEvent *e; @@ -693,9 +699,9 @@ guint lttv_process_traceset_middle(LttvTracesetContext *self, guint read_ret; - enum read_state last_read_state = LAST_NONE; + //enum read_state last_read_state = LAST_NONE; - gboolean last_ret = FALSE; /* return value of the last hook list called */ + gint last_ret = 0; /* return value of the last hook list called */ /* Get the next event from the pqueue, call its hooks, reinsert in the pqueue the following event from the same tracefile @@ -747,22 +753,32 @@ guint lttv_process_traceset_middle(LttvTracesetContext *self, g_tree_foreach(pqueue, test_tree, tfc); #endif //DEBUG + e = ltt_tracefile_get_event(tfc->tf); - if(last_read_state != LAST_EMPTY) { - /* Only call hooks if the last read has given an event or if we are at the - * first pass (not if last read returned end of tracefile) */ - count++; - - fac_id = ltt_event_facility_id(e); - ev_id = ltt_event_eventtype_id(e); - id = GET_HOOK_ID(fac_id, ev_id); - last_ret = lttv_hooks_call_merge(tfc->event, tfc, - lttv_hooks_by_id_get(tfc->event_by_id, id), tfc); - } + //if(last_read_state != LAST_EMPTY) { + /* Only call hooks if the last read has given an event or if we are at the + * first pass (not if last read returned end of tracefile) */ + count++; - read_ret = ltt_tracefile_read(tfc->tf); + tfc->target_pid = -1; /* unset target PID */ + /* Hooks : + * return values : 0 : continue read, 1 : go to next position and stop read, + * 2 : stay at the current position and stop read */ + last_ret = lttv_hooks_call_merge(tfc->event, tfc, + lttv_hooks_by_id_get(tfc->event_by_id, e->event_id), tfc); +#if 0 + /* This is buggy : it won't work well with state computation */ + if(unlikely(last_ret == 2)) { + /* This is a case where we want to stay at this position and stop read. */ + g_tree_insert(pqueue, tfc, tfc); + return count - 1; + } +#endif //0 + read_ret = ltt_tracefile_read(tfc->tf); + + if(likely(!read_ret)) { //g_debug("An event is ready"); tfc->timestamp = ltt_event_time(e); @@ -775,12 +791,12 @@ guint lttv_process_traceset_middle(LttvTracesetContext *self, g_tree_foreach(pqueue, test_tree, NULL); #endif //DEBUG - last_read_state = LAST_OK; + //last_read_state = LAST_OK; } else { tfc->timestamp = ltt_time_infinite; if(read_ret == ERANGE) { - last_read_state = LAST_EMPTY; + // last_read_state = LAST_EMPTY; g_debug("End of trace"); } else g_error("Error happened in lttv_process_traceset_middle"); @@ -827,7 +843,7 @@ void lttv_process_trace_seek_time(LttvTraceContext *self, LttTime start) for(i = 0 ; i < nb_tracefile ; i++) { tfc = &g_array_index(self->tracefiles, LttvTracefileContext*, i); - //g_tree_remove(pqueue, *tfc); + g_tree_remove(pqueue, *tfc); ret = ltt_tracefile_seek_time((*tfc)->tf, start); if(ret == EPERM) g_error("error in lttv_process_trace_seek_time seek"); @@ -858,8 +874,8 @@ void lttv_process_traceset_seek_time(LttvTracesetContext *self, LttTime start) LttvTraceContext *tc; - g_tree_destroy(self->pqueue); - self->pqueue = g_tree_new(compare_tracefile); + //g_tree_destroy(self->pqueue); + //self->pqueue = g_tree_new(compare_tracefile); nb_trace = lttv_traceset_number(self->ts); for(i = 0 ; i < nb_trace ; i++) { @@ -873,24 +889,45 @@ gboolean lttv_process_traceset_seek_position(LttvTracesetContext *self, const LttvTracesetContextPosition *pos) { guint i; - - /* If a position is set, seek the traceset to this position */ + /* If a position is set, seek the traceset to this position */ if(ltt_time_compare(pos->timestamp, ltt_time_infinite) != 0) { - g_tree_destroy(self->pqueue); - self->pqueue = g_tree_new(compare_tracefile); + + /* Test to see if the traces has been added to the trace set : + * It should NEVER happen. Clear all positions if a new trace comes in. */ + /* FIXME I know this test is not optimal : should keep a number of + * tracefiles variable in the traceset.. eventually */ + guint num_traces = lttv_traceset_number(self->ts); + guint tf_count = 0; + for(i=0; itraces[i]->tracefiles; + guint j; + guint num_tracefiles = tracefiles->len; + for(j=0;jtfcp->len); + + + //g_tree_destroy(self->pqueue); + //self->pqueue = g_tree_new(compare_tracefile); - for(i=0;iep->len; i++) { - LttEventPosition **ep = &g_array_index(pos->ep, LttEventPosition*, i); - LttvTracefileContext **tfc = - &g_array_index(pos->tfc, LttvTracefileContext*, i); - if(*ep != NULL) { - if(ltt_tracefile_seek_position((*tfc)->tf, *ep) != 0) + for(i=0;itfcp->len; i++) { + LttvTracefileContextPosition *tfcp = + &g_array_index(pos->tfcp, LttvTracefileContextPosition, i); + + g_tree_remove(self->pqueue, tfcp->tfc); + + if(tfcp->used == TRUE) { + if(ltt_tracefile_seek_position(tfcp->tfc->tf, tfcp->event) != 0) return 1; - (*tfc)->timestamp = ltt_event_time(ltt_tracefile_get_event((*tfc)->tf)); - g_assert(ltt_time_compare((*tfc)->timestamp, ltt_time_infinite) != 0); - g_tree_insert(self->pqueue, (*tfc), (*tfc)); + tfcp->tfc->timestamp = + ltt_event_time(ltt_tracefile_get_event(tfcp->tfc->tf)); + g_assert(ltt_time_compare(tfcp->tfc->timestamp, + ltt_time_infinite) != 0); + g_tree_insert(self->pqueue, tfcp->tfc, tfcp->tfc); + } else { - (*tfc)->timestamp = ltt_time_infinite; + tfcp->tfc->timestamp = ltt_time_infinite; } } } @@ -907,178 +944,140 @@ gboolean lttv_process_traceset_seek_position(LttvTracesetContext *self, } - +#if 0 // pmf: temporary disable static LttField * find_field(LttEventType *et, const GQuark field) { - LttType *t; - LttField *f; - guint i, nb; - - GQuark name; - - /* Field is unset */ if(field == 0) return NULL; - f = ltt_eventtype_field(et); - t = ltt_eventtype_type(et); - g_assert(ltt_type_class(t) == LTT_STRUCT); - nb = ltt_type_member_number(t); - for(i = 0 ; i < nb ; i++) { - ltt_type_member_type(t, i, &name); - if(name == field) break; + f = ltt_eventtype_field_by_name(et, field); + if (!f) { + g_warning("Cannot find field %s in event %s.%s", g_quark_to_string(field), + g_quark_to_string(ltt_facility_name(ltt_eventtype_facility(et))), + g_quark_to_string(ltt_eventtype_name(et))); } - g_assert(i < nb); - return ltt_field_member(f, i); -} -LttvTraceHookByFacility *lttv_trace_hook_get_fac(LttvTraceHook *th, - guint facility_id) -{ - return &g_array_index(th->fac_index, LttvTraceHookByFacility, facility_id); + return f; } +#endif -/* Get the first facility corresponding to the name. As the types must be - * compatible, it is relevant to use the field name and sizes of the first - * facility to create data structures and assume the data will be compatible - * thorough the trace */ -LttvTraceHookByFacility *lttv_trace_hook_get_first(LttvTraceHook *th) +struct marker_info *lttv_trace_hook_get_marker(LttTrace *t, LttvTraceHook *th) { - g_assert(th->fac_list->len > 0); - return g_array_index(th->fac_list, LttvTraceHookByFacility*, 0); + return marker_get_info_from_id(t, th->id); } -/* Returns 0 on success, -1 if fails. */ -gint -lttv_trace_find_hook(LttTrace *t, GQuark facility, GQuark event, - GQuark field1, GQuark field2, GQuark field3, LttvHook h, gpointer hook_data, - LttvTraceHook *th) +int lttv_trace_find_hook(LttTrace *t, GQuark marker_name, + GQuark fields[], LttvHook h, gpointer hook_data, GArray **trace_hooks) { - LttFacility *f; - - LttEventType *et, *first_et; - - GArray *facilities; - - guint i, fac_id, ev_id; - - LttvTraceHookByFacility *thf, *first_thf; - - facilities = ltt_trace_facility_get_by_name(t, facility); - - if(unlikely(facilities == NULL)) goto facility_error; - - th->fac_index = g_array_sized_new(FALSE, TRUE, - sizeof(LttvTraceHookByFacility), - NUM_FACILITIES); - th->fac_index = g_array_set_size(th->fac_index, NUM_FACILITIES); - - th->fac_list = g_array_sized_new(FALSE, TRUE, - sizeof(LttvTraceHookByFacility*), - facilities->len); - th->fac_list = g_array_set_size(th->fac_list, facilities->len); - - fac_id = g_array_index(facilities, guint, 0); - f = ltt_trace_get_facility_by_num(t, fac_id); - - et = ltt_facility_eventtype_get_by_name(f, event); - if(unlikely(et == NULL)) goto event_error; - - thf = &g_array_index(th->fac_index, LttvTraceHookByFacility, fac_id); - g_array_index(th->fac_list, LttvTraceHookByFacility*, 0) = thf; - - ev_id = ltt_eventtype_id(et); - - thf->h = h; - thf->id = GET_HOOK_ID(fac_id, ev_id); - thf->f1 = find_field(et, field1); - thf->f2 = find_field(et, field2); - thf->f3 = find_field(et, field3); - thf->hook_data = hook_data; - - first_thf = thf; - first_et = et; - - /* Check for type compatibility too */ - for(i=1;ilen;i++) { - fac_id = g_array_index(facilities, guint, i); - f = ltt_trace_get_facility_by_num(t, fac_id); - - et = ltt_facility_eventtype_get_by_name(f, event); - if(unlikely(et == NULL)) goto event_error; - - thf = &g_array_index(th->fac_index, LttvTraceHookByFacility, fac_id); - g_array_index(th->fac_list, LttvTraceHookByFacility*, i) = thf; - ev_id = ltt_eventtype_id(et); - thf->h = h; - thf->id = GET_HOOK_ID(fac_id, ev_id); - thf->f1 = find_field(et, field1); - if(check_fields_compatibility(first_et, et, - first_thf->f1, thf->f1)) - goto type_error; - - thf->f2 = find_field(et, field2); - if(check_fields_compatibility(first_et, et, - first_thf->f2, thf->f2)) - goto type_error; - - thf->f3 = find_field(et, field3); - if(check_fields_compatibility(first_et, et, - first_thf->f3, thf->f3)) - goto type_error; - thf->hook_data = hook_data; + struct marker_info *info; + struct marker_field *field; + guint16 marker_id; + int init_array_size; + + info = marker_get_info_from_name(t, marker_name); + if(unlikely(info == NULL)) { + return NULL; } - return 0; - -type_error: - goto free; -event_error: - g_error("Event type does not exist for event %s", - g_quark_to_string(event)); - goto free; -facility_error: - g_error("No %s facility", g_quark_to_string(facility)); - goto free; -free: - g_array_free(th->fac_index, TRUE); - g_array_free(th->fac_list, TRUE); - th->fac_index = NULL; - th->fac_list = NULL; - return -1; + init_array_size = (*trace_hooks)->len; + + /* for each marker with the requested name */ + do { + LttvTraceHook tmpth; + int found; + GQuark f; + + marker_id = marker_get_id_from_info(t, info); + + tmpth.h = h; + tmpth.id = marker_id; + tmpth.hook_data = hook_data; + tmpth.fields = g_ptr_array_new(); + + /* for each field requested */ + for(f = fields; f && *f != 0; f++) { + found = 0; + for_each_marker_field(marker_field, info) { + if(marker_fieldfield->name == *f) { + found = 1; + g_ptr_array_add(tmpth.fields, marker_field); + break; + } + } + if(!found) { + /* Did not find the one of the fields in this instance of the + marker. Print a warning and skip this marker completely. + Still iterate on other markers with same name. */ + g_ptr_array_free(tmpth.fields, TRUE); + g_warning("Field %s cannot be found in marker %s", + g_quark_to_string(*f), g_quark_to_string(marker_name)); + goto skip_marker; + } + } + /* all fields were found: add the tracehook to the array */ + *trace_hooks = g_array_append_val(*trace_hooks, tmpth); +skip_marker: + info = info->next; + } while(info != NULL); + + /* Error if no new trace hook has been added */ + return (init_array_size == (*trace_hooks)->len); } -void lttv_trace_hook_destroy(LttvTraceHook *th) +void lttv_trace_hook_remove_all(GArray **th) { - g_array_free(th->fac_index, TRUE); - g_array_free(th->fac_list, TRUE); + int i; + for(i=0; ilen; i++) { + g_ptr_array_free(g_array_index(th, LttvTraceHook, i).fields, TRUE); + } + *th = g_array_remove_range(*th, 0, th->len); } - -LttvTracesetContextPosition *lttv_traceset_context_position_new() +LttvTracesetContextPosition *lttv_traceset_context_position_new( + const LttvTracesetContext *self) { - LttvTracesetContextPosition *pos = g_new(LttvTracesetContextPosition,1); - pos->ep = g_array_sized_new(FALSE, TRUE, sizeof(LttEventPosition*), - 10); - pos->tfc = g_array_sized_new(FALSE, TRUE, sizeof(LttvTracefileContext*), - 10); + guint num_traces = lttv_traceset_number(self->ts); + guint tf_count = 0; + guint i; + + for(i=0; itraces[i]->tracefiles; + guint j; + guint num_tracefiles = tracefiles->len; + for(j=0;jtfcp = g_array_sized_new(FALSE, TRUE, + sizeof(LttvTracefileContextPosition), + tf_count); + g_array_set_size(pos->tfcp, tf_count); + for(i=0;itfcp->len;i++) { + LttvTracefileContextPosition *tfcp = + &g_array_index(pos->tfcp, LttvTracefileContextPosition, i); + tfcp->event = ltt_event_position_new(); + } + pos->timestamp = ltt_time_infinite; return pos; } /* Save all positions, the ones with infinite time will have NULL * ep. */ +/* note : a position must be destroyed when a trace is added/removed from a + * traceset */ void lttv_traceset_context_position_save(const LttvTracesetContext *self, LttvTracesetContextPosition *pos) { guint i; guint num_traces = lttv_traceset_number(self->ts); + guint tf_count = 0; - pos->tfc = g_array_set_size(pos->tfc, 0); - pos->ep = g_array_set_size(pos->ep, 0); + pos->timestamp = ltt_time_infinite; for(i=0; itraces[i]->tracefiles; @@ -1086,22 +1085,27 @@ void lttv_traceset_context_position_save(const LttvTracesetContext *self, guint num_tracefiles = tracefiles->len; for(j=0;jtfcp->len); LttvTracefileContext **tfc = &g_array_index(tracefiles, LttvTracefileContext*, j); + LttvTracefileContextPosition *tfcp = + &g_array_index(pos->tfcp, LttvTracefileContextPosition, tf_count); - LttEvent *event = ltt_tracefile_get_event((*tfc)->tf); - LttEventPosition *ep; + tfcp->tfc = *tfc; if(ltt_time_compare((*tfc)->timestamp, ltt_time_infinite) != 0) { - ep = ltt_event_position_new(); - ltt_event_position(event, ep); + LttEvent *event = ltt_tracefile_get_event((*tfc)->tf); + ltt_event_position(event, tfcp->event); if(ltt_time_compare((*tfc)->timestamp, pos->timestamp) < 0) pos->timestamp = (*tfc)->timestamp; + tfcp->used = TRUE; } else { - ep = NULL; + tfcp->used = FALSE; } - g_array_append_val(pos->tfc, *tfc); - g_array_append_val(pos->ep, ep); + + //g_array_append_val(pos->tfc, *tfc); + //g_array_append_val(pos->ep, ep); + tf_count++; } } @@ -1110,15 +1114,15 @@ void lttv_traceset_context_position_save(const LttvTracesetContext *self, void lttv_traceset_context_position_destroy(LttvTracesetContextPosition *pos) { int i; - LttEventPosition **ep; - for(i=0;iep->len;i++) { - ep = &g_array_index(pos->ep, LttEventPosition*, i); - if(*ep != NULL) - g_free(*ep); + for(i=0;itfcp->len;i++) { + LttvTracefileContextPosition *tfcp = + &g_array_index(pos->tfcp, LttvTracefileContextPosition, i); + g_free(tfcp->event); + tfcp->event = NULL; + tfcp->used = FALSE; } - g_array_free(pos->ep, TRUE); - g_array_free(pos->tfc, TRUE); + g_array_free(pos->tfcp, TRUE); g_free(pos); } @@ -1126,25 +1130,24 @@ void lttv_traceset_context_position_copy(LttvTracesetContextPosition *dest, const LttvTracesetContextPosition *src) { int i; - LttEventPosition **src_ep, **dest_ep; + LttvTracefileContextPosition *src_tfcp, *dest_tfcp; - dest->ep = g_array_set_size(dest->ep, src->ep->len); - dest->tfc = g_array_set_size(dest->tfc, src->tfc->len); + g_assert(src->tfcp->len == src->tfcp->len); - for(i=0;iep->len;i++) { - src_ep = &g_array_index(src->ep, LttEventPosition*, i); - dest_ep = &g_array_index(dest->ep, LttEventPosition*, i); - if(*src_ep != NULL) { - *dest_ep = ltt_event_position_new(); + for(i=0;itfcp->len;i++) { + src_tfcp = + &g_array_index(src->tfcp, LttvTracefileContextPosition, i); + dest_tfcp = + &g_array_index(dest->tfcp, LttvTracefileContextPosition, i); + + dest_tfcp->used = src_tfcp->used; + dest_tfcp->tfc = src_tfcp->tfc; + + if(src_tfcp->used) { ltt_event_position_copy( - *dest_ep, - *src_ep); - } else - *dest_ep = NULL; - } - for(i=0;itfc->len;i++) { - g_array_index(dest->tfc, LttvTracefileContext*, i) = - g_array_index(src->tfc, LttvTracefileContext*, i); + dest_tfcp->event, + src_tfcp->event); + } } dest->timestamp = src->timestamp; } @@ -1155,30 +1158,29 @@ gint lttv_traceset_context_ctx_pos_compare(const LttvTracesetContext *self, int i; int ret = 0; - if(pos->ep->len == 0) { + if(pos->tfcp->len == 0) { if(lttv_traceset_number(self->ts) == 0) return 0; else return 1; } if(lttv_traceset_number(self->ts) == 0) return -1; - for(i=0;iep->len;i++) { - LttEventPosition *ep = g_array_index(pos->ep, LttEventPosition*, i); - LttvTracefileContext *tfc = - g_array_index(pos->tfc, LttvTracefileContext*, i); + for(i=0;itfcp->len;i++) { + LttvTracefileContextPosition *tfcp = + &g_array_index(pos->tfcp, LttvTracefileContextPosition, i); - if(ep == NULL) { - if(ltt_time_compare(tfc->timestamp, ltt_time_infinite) != 0) { + if(tfcp->used == FALSE) { + if(ltt_time_compare(tfcp->tfc->timestamp, ltt_time_infinite) < 0) { ret = -1; } } else { - if(ltt_time_compare(tfc->timestamp, ltt_time_infinite) == 0) { + if(ltt_time_compare(tfcp->tfc->timestamp, ltt_time_infinite) == 0) { ret = 1; } else { - LttEvent *event = ltt_tracefile_get_event(tfc->tf); + LttEvent *event = ltt_tracefile_get_event(tfcp->tfc->tf); ret = ltt_event_position_compare((LttEventPosition*)event, - ep); + tfcp->event); } } if(ret != 0) return ret; @@ -1193,42 +1195,44 @@ gint lttv_traceset_context_pos_pos_compare( const LttvTracesetContextPosition *pos2) { int i, j; - int ret; + int ret = 0; - if(pos1->ep->len == 0) { - if(pos2->ep->len == 0) return 0; - else return 1; + if(ltt_time_compare(pos1->timestamp, ltt_time_infinite) == 0) { + if(ltt_time_compare(pos2->timestamp, ltt_time_infinite) == 0) + return 0; + else + return 1; } - if(pos2->ep->len == 0) + if(ltt_time_compare(pos2->timestamp, ltt_time_infinite) == 0) return -1; - for(i=0;iep->len;i++) { - LttEventPosition *ep1 = g_array_index(pos1->ep, LttEventPosition*, i); - LttvTracefileContext *tfc1 = g_array_index(pos1->tfc, - LttvTracefileContext*, i); + for(i=0;itfcp->len;i++) { + LttvTracefileContextPosition *tfcp1 = + &g_array_index(pos1->tfcp, LttvTracefileContextPosition, i); - if(ep1 != NULL) { - for(j=0;jep->len;j++) { - LttEventPosition *ep2 = g_array_index(pos2->ep, LttEventPosition*, j); - LttvTracefileContext *tfc2 = g_array_index(pos2->tfc, - LttvTracefileContext*, j); - if(tfc1 == tfc2) { - if(ep2 != NULL) - ret = ltt_event_position_compare(ep1, ep2); + if(tfcp1->used == TRUE) { + for(j=0;jtfcp->len;j++) { + LttvTracefileContextPosition *tfcp2 = + &g_array_index(pos2->tfcp, LttvTracefileContextPosition, j); + + if(tfcp1->tfc == tfcp2->tfc) { + if(tfcp2->used == TRUE) + ret = ltt_event_position_compare(tfcp1->event, tfcp2->event); else ret = -1; if(ret != 0) return ret; } } + } else { - for(j=0;jep->len;j++) { - LttEventPosition *ep2 = g_array_index(pos2->ep, LttEventPosition*, j); - LttvTracefileContext *tfc2 = g_array_index(pos2->tfc, - LttvTracefileContext*, j); - if(tfc1 == tfc2) { - if(ep2 != NULL) ret = 1; - } + for(j=0;jtfcp->len;j++) { + LttvTracefileContextPosition *tfcp2 = + &g_array_index(pos2->tfcp, LttvTracefileContextPosition, j); + + if(tfcp1->tfc == tfcp2->tfc) + if(tfcp2->used == TRUE) ret = 1; + if(ret != 0) return ret; } } } @@ -1273,3 +1277,341 @@ void lttv_process_traceset_get_sync_data(LttvTracesetContext *tsc) lttv_traceset_context_position_save(tsc, tsc->sync_position); } +struct seek_back_data { + guint first_event; /* Index of the first event in the array : we will always + overwrite at this position : this is a circular array. + */ + guint events_found; + guint n; /* number of events requested */ + GPtrArray *array; /* array of LttvTracesetContextPositions pointers */ + LttvFilter *filter1; + LttvFilter *filter2; + LttvFilter *filter3; + gpointer data; + check_handler *check; + gboolean *stop_flag; + guint raw_event_count; +}; + +static gint seek_back_event_hook(void *hook_data, void* call_data) +{ + struct seek_back_data *sd = (struct seek_back_data*)hook_data; + LttvTracefileContext *tfc = (LttvTracefileContext*)call_data; + LttvTracesetContext *tsc = tfc->t_context->ts_context; + LttvTracesetContextPosition *pos; + + if(sd->check && sd->check(sd->raw_event_count, sd->stop_flag, sd->data)) + return TRUE; + sd->raw_event_count++; + + if(sd->filter1 != NULL && sd->filter1->head != NULL && + !lttv_filter_tree_parse(sd->filter1->head, + ltt_tracefile_get_event(tfc->tf), + tfc->tf, + tfc->t_context->t, + tfc,NULL,NULL)) { + return FALSE; + } + if(sd->filter2 != NULL && sd->filter2->head != NULL && + !lttv_filter_tree_parse(sd->filter2->head, + ltt_tracefile_get_event(tfc->tf), + tfc->tf, + tfc->t_context->t, + tfc,NULL,NULL)) { + return FALSE; + } + if(sd->filter3 != NULL && sd->filter3->head != NULL && + !lttv_filter_tree_parse(sd->filter3->head, + ltt_tracefile_get_event(tfc->tf), + tfc->tf, + tfc->t_context->t, + tfc,NULL,NULL)) { + return FALSE; + } + + pos = (LttvTracesetContextPosition*)g_ptr_array_index (sd->array, + sd->first_event); + + lttv_traceset_context_position_save(tsc, pos); + + if(sd->first_event >= sd->array->len - 1) sd->first_event = 0; + else sd->first_event++; + + sd->events_found = min(sd->n, sd->events_found + 1); + + return FALSE; +} + +/* Seek back n events back from the current position. + * + * Parameters : + * @self The trace set context + * @n number of events to jump over + * @first_offset The initial offset value used. + * never put first_offset at ltt_time_zero. + * @time_seeker Function pointer of the function to use to seek time : + * either lttv_process_traceset_seek_time + * or lttv_state_traceset_seek_time_closest + * @filter The filter to call. + * + * Return value : the number of events found (might be lower than the number + * requested if beginning of traceset is reached). + * + * The first search will go back first_offset and try to find the last n events + * matching the filter. If there are not enough, it will try to go back from the + * new trace point from first_offset*2, and so on, until beginning of trace or n + * events are found. + * + * Note : this function does not take in account the LttvFilter : use the + * similar function found in state.c instead. + * + * Note2 : the caller must make sure that the LttvTracesetContext does not + * contain any hook, as process_traceset_middle is used in this routine. + */ +guint lttv_process_traceset_seek_n_backward(LttvTracesetContext *self, + guint n, LttTime first_offset, + seek_time_fct time_seeker, + check_handler *check, + gboolean *stop_flag, + LttvFilter *filter1, + LttvFilter *filter2, + LttvFilter *filter3, + gpointer data) +{ + if(lttv_traceset_number(self->ts) == 0) return 0; + g_assert(ltt_time_compare(first_offset, ltt_time_zero) != 0); + + guint i; + LttvTracesetContextPosition *next_iter_end_pos = + lttv_traceset_context_position_new(self); + LttvTracesetContextPosition *end_pos = + lttv_traceset_context_position_new(self); + LttvTracesetContextPosition *saved_pos = + lttv_traceset_context_position_new(self); + LttTime time; + LttTime asked_time; + LttTime time_offset; + struct seek_back_data sd; + LttvHooks *hooks = lttv_hooks_new(); + + sd.first_event = 0; + sd.events_found = 0; + sd.array = g_ptr_array_sized_new(n); + sd.filter1 = filter1; + sd.filter2 = filter2; + sd.filter3 = filter3; + sd.data = data; + sd.n = n; + sd.check = check; + sd.stop_flag = stop_flag; + sd.raw_event_count = 0; + g_ptr_array_set_size(sd.array, n); + for(i=0;itime_span.end_time) > 0) { + time = self->time_span.end_time; + } + asked_time = time; + time_offset = first_offset; + + lttv_hooks_add(hooks, seek_back_event_hook, &sd, LTTV_PRIO_DEFAULT); + + lttv_process_traceset_begin(self, NULL, NULL, NULL, hooks, NULL); + + while(1) { + /* stop criteria : - n events found + * - asked_time < beginning of trace */ + if(ltt_time_compare(asked_time, self->time_span.start_time) < 0) break; + + lttv_traceset_context_position_copy(end_pos, next_iter_end_pos); + + /* We must seek the traceset back to time - time_offset */ + /* this time becomes the new reference time */ + time = ltt_time_sub(time, time_offset); + asked_time = time; + + time_seeker(self, time); + lttv_traceset_context_position_save(self, next_iter_end_pos); + /* Resync the time in case of a seek_closest */ + time = lttv_traceset_context_position_get_time(next_iter_end_pos); + if(ltt_time_compare(time, self->time_span.end_time) > 0) { + time = self->time_span.end_time; + } + + /* Process the traceset, calling a hook which adds events + * to the array, overwriting the tail. It changes first_event and + * events_found too. */ + /* We would like to have a clean context here : no other hook than our's */ + + lttv_process_traceset_middle(self, ltt_time_infinite, + G_MAXUINT, end_pos); + + if(sd.events_found < n) { + if(sd.first_event > 0) { + /* Save the first position */ + LttvTracesetContextPosition *pos = + (LttvTracesetContextPosition*)g_ptr_array_index (sd.array, 0); + lttv_traceset_context_position_copy(saved_pos, pos); + } + g_assert(n-sd.events_found <= sd.array->len); + /* Change array size to n - events_found */ + for(i=n-sd.events_found;ilen;i++) { + LttvTracesetContextPosition *pos = + (LttvTracesetContextPosition*)g_ptr_array_index (sd.array, i); + lttv_traceset_context_position_destroy(pos); + } + g_ptr_array_set_size(sd.array, n-sd.events_found); + sd.first_event = 0; + + } else break; /* Second end criterion : n events found */ + + time_offset = ltt_time_mul(time_offset, BACKWARD_SEEK_MUL); + } + + lttv_traceset_context_position_destroy(end_pos); + lttv_traceset_context_position_destroy(next_iter_end_pos); + + lttv_process_traceset_end(self, NULL, NULL, NULL, hooks, NULL); + + if(sd.events_found >= n) { + /* Seek the traceset to the first event in the circular array */ + LttvTracesetContextPosition *pos = + (LttvTracesetContextPosition*)g_ptr_array_index (sd.array, + sd.first_event); + g_assert(lttv_process_traceset_seek_position(self, pos) == 0); + } else { + /* Will seek to the last saved position : in the worst case, it will be the + * original position (if events_found is 0) */ + g_assert(lttv_process_traceset_seek_position(self, saved_pos) == 0); + } + + for(i=0;ilen;i++) { + LttvTracesetContextPosition *pos = + (LttvTracesetContextPosition*)g_ptr_array_index (sd.array, i); + lttv_traceset_context_position_destroy(pos); + } + g_ptr_array_free(sd.array, TRUE); + + lttv_hooks_destroy(hooks); + + lttv_traceset_context_position_destroy(saved_pos); + + return sd.events_found; +} + + +struct seek_forward_data { + guint event_count; /* event counter */ + guint n; /* requested number of events to jump over */ + LttvFilter *filter1; + LttvFilter *filter2; + LttvFilter *filter3; + gpointer data; + check_handler *check; + gboolean *stop_flag; + guint raw_event_count; /* event counter */ +}; + +static gint seek_forward_event_hook(void *hook_data, void* call_data) +{ + struct seek_forward_data *sd = (struct seek_forward_data*)hook_data; + LttvTracefileContext *tfc = (LttvTracefileContext*)call_data; + + if(sd->check && sd->check(sd->raw_event_count, sd->stop_flag, sd->data)) + return TRUE; + sd->raw_event_count++; + + if(sd->filter1 != NULL && sd->filter1->head != NULL && + !lttv_filter_tree_parse(sd->filter1->head, + ltt_tracefile_get_event(tfc->tf), + tfc->tf, + tfc->t_context->t, + tfc,NULL,NULL)) { + return FALSE; + } + if(sd->filter2 != NULL && sd->filter2->head != NULL && + !lttv_filter_tree_parse(sd->filter2->head, + ltt_tracefile_get_event(tfc->tf), + tfc->tf, + tfc->t_context->t, + tfc,NULL,NULL)) { + return FALSE; + } + if(sd->filter3 != NULL && sd->filter3->head != NULL && + !lttv_filter_tree_parse(sd->filter3->head, + ltt_tracefile_get_event(tfc->tf), + tfc->tf, + tfc->t_context->t, + tfc,NULL,NULL)) { + return FALSE; + } + + sd->event_count++; + if(sd->event_count >= sd->n) + return TRUE; +} + +/* Seek back n events forward from the current position (1 to n) + * 0 is ok too, but it will actually do nothing. + * + * Parameters : + * @self the trace set context + * @n number of events to jump over + * @filter filter to call. + * + * returns : the number of events jumped over (may be less than requested if end + * of traceset reached) */ +guint lttv_process_traceset_seek_n_forward(LttvTracesetContext *self, + guint n, + check_handler *check, + gboolean *stop_flag, + LttvFilter *filter1, + LttvFilter *filter2, + LttvFilter *filter3, + gpointer data) +{ + struct seek_forward_data sd; + sd.event_count = 0; + sd.n = n; + sd.filter1 = filter1; + sd.filter2 = filter2; + sd.filter3 = filter3; + sd.data = data; + sd.check = check; + sd.stop_flag = stop_flag; + sd.raw_event_count = 0; + + if(sd.event_count >= sd.n) return sd.event_count; + + LttvHooks *hooks = lttv_hooks_new(); + + lttv_hooks_add(hooks, seek_forward_event_hook, &sd, LTTV_PRIO_DEFAULT); + + lttv_process_traceset_begin(self, NULL, NULL, NULL, hooks, NULL); + + /* it will end on the end of traceset, or the fact that the + * hook returns TRUE. + */ + lttv_process_traceset_middle(self, ltt_time_infinite, + G_MAXUINT, NULL); + + /* Here, our position is either the end of traceset, or the exact position + * after n events : leave it like this. This might be placed on an event that + * will be filtered out, we don't care : all we know is that the following + * event filtered in will be the right one. */ + + lttv_process_traceset_end(self, NULL, NULL, NULL, hooks, NULL); + + lttv_hooks_destroy(hooks); + + return sd.event_count; +} + +