}
-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,
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);
+ fac_id = ltt_event_facility_id(e);
+ ev_id = ltt_event_eventtype_id(e);
+ id = GET_HOOK_ID(fac_id, ev_id);
+ /* 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, 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->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)
const LttvTracesetContextPosition *pos2)
{
int i, j;
- int ret;
+ int ret = 0;
- if(pos1->tfcp->len == 0) {
- if(pos2->tfcp->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->tfcp->len == 0)
+ if(ltt_time_compare(pos2->timestamp, ltt_time_infinite) == 0)
return -1;
for(i=0;i<pos1->tfcp->len;i++) {
LttvTracesetContext *tsc = tfc->t_context->ts_context;
LttvTracesetContextPosition *pos;
- if(sd->filter != NULL) {
+ if(sd->filter != NULL && sd->filter->head != NULL) {
if(!lttv_filter_tree_parse(sd->filter->head,
ltt_tracefile_get_event(tfc->tf),
tfc->tf,
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();
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 *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->filter == NULL || lttv_filter_tree_parse(sd->filter->head,
ltt_tracefile_get_event(tfc->tf),
tfc->tf,
tfc->t_context->t,
- tfc))
- return FALSE;
+ tfc)) {
+ sd->event_count++;
+ if(sd->event_count >= sd->n)
+ return TRUE;
}
-
- sd->event_count++;
-
- if(sd->event_count >= sd->n)
- return TRUE;
- else
- return FALSE;
+ return FALSE;
}
-/* 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
sd.event_count = 0;
sd.n = n;
sd.filter = filter;
+
+ 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