#endif
#include <string.h>
+#include <lttv/lttv.h>
#include <lttv/tracecontext.h>
#include <ltt/event.h>
-#include <ltt/facility.h>
#include <ltt/trace.h>
-#include <ltt/type.h>
#include <lttv/filter.h>
#include <errno.h>
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
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;
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;
}
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;
#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);
}
-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,
{
GTree *pqueue = self->pqueue;
- guint fac_id, ev_id, id;
-
LttvTracefileContext *tfc;
LttEvent *e;
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
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);
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");
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");
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++) {
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; i<num_traces;i++) {
+ GArray * tracefiles = self->traces[i]->tracefiles;
+ guint j;
+ guint num_tracefiles = tracefiles->len;
+ for(j=0;j<num_tracefiles;j++)
+ tf_count++;
+ }
+ g_assert(tf_count == pos->tfcp->len);
+
+
+ //g_tree_destroy(self->pqueue);
+ //self->pqueue = g_tree_new(compare_tracefile);
- for(i=0;i<pos->ep->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;i<pos->tfcp->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;
}
}
}
}
-
+#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;i<facilities->len;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 != 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_destroy(GArray **th)
{
- g_array_free(th->fac_index, TRUE);
- g_array_free(th->fac_list, TRUE);
+ int i;
+ for(i=0; i<th->len; 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; i<num_traces;i++) {
+ GArray * tracefiles = self->traces[i]->tracefiles;
+ guint j;
+ guint num_tracefiles = tracefiles->len;
+ for(j=0;j<num_tracefiles;j++)
+ tf_count++;
+ }
+ LttvTracesetContextPosition *pos =
+ g_new(LttvTracesetContextPosition, 1);
+ pos->tfcp = g_array_sized_new(FALSE, TRUE,
+ sizeof(LttvTracefileContextPosition),
+ tf_count);
+ g_array_set_size(pos->tfcp, tf_count);
+ for(i=0;i<pos->tfcp->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;
- for(i=0;i<pos->ep->len;i++){
- LttEventPosition *ep = g_array_index(pos->ep, LttEventPosition*, i);
- if(ep != NULL) g_free(ep);
- }
-
- 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; i<num_traces;i++) {
guint num_tracefiles = tracefiles->len;
for(j=0;j<num_tracefiles;j++) {
+ g_assert(tf_count < pos->tfcp->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++;
}
}
void lttv_traceset_context_position_destroy(LttvTracesetContextPosition *pos)
{
int i;
- LttEventPosition **ep;
- for(i=0;i<pos->ep->len;i++) {
- ep = &g_array_index(pos->ep, LttEventPosition*, i);
- if(*ep != NULL)
- g_free(*ep);
+ for(i=0;i<pos->tfcp->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);
}
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;i<src->ep->len;i++) {
- src_ep = &g_array_index(src->ep, LttEventPosition*, i);
- dest_ep = &g_array_index(dest->ep, LttEventPosition*, i);
- if(*src_ep != NULL) {
- if(*dest_ep == NULL) *dest_ep = ltt_event_position_new();
+ for(i=0;i<src->tfcp->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;i<src->tfc->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;
}
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;i<pos->ep->len;i++) {
- LttEventPosition *ep = g_array_index(pos->ep, LttEventPosition*, i);
- LttvTracefileContext *tfc =
- g_array_index(pos->tfc, LttvTracefileContext*, i);
+ for(i=0;i<pos->tfcp->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;
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;i<pos1->ep->len;i++) {
- LttEventPosition *ep1 = g_array_index(pos1->ep, LttEventPosition*, i);
- LttvTracefileContext *tfc1 = g_array_index(pos1->tfc,
- LttvTracefileContext*, i);
+ for(i=0;i<pos1->tfcp->len;i++) {
+ LttvTracefileContextPosition *tfcp1 =
+ &g_array_index(pos1->tfcp, LttvTracefileContextPosition, i);
- if(ep1 != NULL) {
- for(j=0;j<pos2->ep->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;j<pos2->tfcp->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;j<pos2->ep->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;j<pos2->tfcp->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;
}
}
}
guint events_found;
guint n; /* number of events requested */
GPtrArray *array; /* array of LttvTracesetContextPositions pointers */
- LttvFilter *filter;
+ 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)
LttvTracesetContext *tsc = tfc->t_context->ts_context;
LttvTracesetContextPosition *pos;
- if(sd->filter != NULL) {
- if(!lttv_filter_tree_parse(sd->filter->head,
+ 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))
- return FALSE;
+ 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);
* Parameters :
* @self The trace set context
* @n number of events to jump over
- * @first_offset The initial offset value used. Hint : try about 100000ns.
+ * @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
guint lttv_process_traceset_seek_n_backward(LttvTracesetContext *self,
guint n, LttTime first_offset,
seek_time_fct time_seeker,
- LttvFilter *filter)
+ 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();
- LttvTracesetContextPosition *end_pos = lttv_traceset_context_position_new();
- LttvTracesetContextPosition *saved_pos = lttv_traceset_context_position_new();
+ 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.filter = filter;
+ 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;i<n;i++) {
- g_ptr_array_index (sd.array, i) = lttv_traceset_context_position_new();
+ g_ptr_array_index (sd.array, i) = lttv_traceset_context_position_new(self);
}
lttv_traceset_context_position_save(self, next_iter_end_pos);
if(ltt_time_compare(time, self->time_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);
while(1) {
/* stop criteria : - n events found
- * - time < beginning of trace */
- if(ltt_time_compare(time, self->time_span.start_time) < 0) break;
+ * - 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);
struct seek_forward_data {
guint event_count; /* event counter */
guint n; /* requested number of events to jump over */
- LttvFilter *filter;
+ 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->filter != NULL) {
- if(!lttv_filter_tree_parse(sd->filter->head,
+ 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))
- return FALSE;
+ 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++;
+ sd->event_count++;
if(sd->event_count >= sd->n)
- return TRUE;
- else
- return FALSE;
+ return TRUE;
}
-/* Seek back n events forward from the current position
+/* 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
* 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, LttvFilter *filter)
+ 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.filter = filter;
+ 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);
G_MAXUINT, NULL);
/* Here, our position is either the end of traceset, or the exact position
- * after n events : leave it like this. */
+ * 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);
projects / lttv.git / blobdiff