X-Git-Url: http://git.efficios.com/?p=babeltrace.git;a=blobdiff_plain;f=lib%2Fiterator.c;h=3dbe878846ab3699af938d2e3a98c202eca8d7b3;hp=4d201dc48942d911edc5647db48837869fcb526a;hb=0d4c669fab9287d78d5d34e3de9e1e701da431cb;hpb=e8c92a62cb474a1bb64bcbfff47c17291751b959 diff --git a/lib/iterator.c b/lib/iterator.c index 4d201dc4..3dbe8788 100644 --- a/lib/iterator.c +++ b/lib/iterator.c @@ -20,12 +20,14 @@ #include #include -#include #include -#include +#include #include #include #include +#include +#include +#include struct stream_saved_pos { /* @@ -35,6 +37,7 @@ struct stream_saved_pos { struct ctf_file_stream *file_stream; size_t cur_index; /* current index in packet index */ ssize_t offset; /* offset from base, in bits. EOF for end of file. */ + uint64_t current_timestamp; }; struct bt_saved_pos { @@ -69,6 +72,294 @@ int stream_compare(void *a, void *b) return 0; } +void bt_iter_free_pos(struct bt_iter_pos *iter_pos) +{ + if (!iter_pos) + return; + + if (iter_pos->u.restore) { + if (iter_pos->u.restore->stream_saved_pos) { + g_array_free( + iter_pos->u.restore->stream_saved_pos, + TRUE); + } + g_free(iter_pos->u.restore); + } + g_free(iter_pos); +} + +/* + * seek_file_stream_by_timestamp + * + * Browse a filestream by index, if an index contains the timestamp passed in + * argument, seek inside the corresponding packet it until we find the event we + * are looking for (either the exact timestamp or the event just after the + * timestamp). + * + * Return 0 if the seek succeded and EOF if we didn't find any packet + * containing the timestamp. + */ +static int seek_file_stream_by_timestamp(struct ctf_file_stream *cfs, + uint64_t timestamp) +{ + struct ctf_stream_pos *stream_pos; + struct packet_index *index; + int i, ret; + + stream_pos = &cfs->pos; + for (i = 0; i < stream_pos->packet_index->len; i++) { + index = &g_array_index(stream_pos->packet_index, + struct packet_index, i); + if (index->timestamp_begin >= timestamp || + index->timestamp_end <= timestamp) + continue; + + stream_pos->packet_seek(&stream_pos->parent, i, SEEK_SET); + while (cfs->parent.timestamp < timestamp) { + ret = stream_read_event(cfs); + if (ret < 0) + break; + } + return 0; + } + return EOF; +} + +/* + * seek_ctf_trace_by_timestamp : for each file stream, seek to the event with + * the corresponding timestamp + * + * Return 0 on success. + * If the timestamp is not part of any file stream, return EOF to inform the + * user the timestamp is out of the scope + */ +static int seek_ctf_trace_by_timestamp(struct ctf_trace *tin, + uint64_t timestamp, struct ptr_heap *stream_heap) +{ + int i, j, ret; + int found = EOF; + + /* for each stream_class */ + for (i = 0; i < tin->streams->len; i++) { + struct ctf_stream_class *stream_class; + + stream_class = g_ptr_array_index(tin->streams, i); + /* for each file_stream */ + for (j = 0; j < stream_class->streams->len; j++) { + struct ctf_stream *stream; + struct ctf_file_stream *cfs; + + stream = g_ptr_array_index(stream_class->streams, j); + cfs = container_of(stream, struct ctf_file_stream, + parent); + ret = seek_file_stream_by_timestamp(cfs, timestamp); + if (ret == 0) { + /* Add to heap */ + ret = heap_insert(stream_heap, cfs); + if (ret) + goto error; + found = 0; + } + } + } + + return found; + +error: + return -2; +} + +int bt_iter_set_pos(struct bt_iter *iter, const struct bt_iter_pos *iter_pos) +{ + struct trace_collection *tc; + int i, ret; + + switch (iter_pos->type) { + case BT_SEEK_RESTORE: + if (!iter_pos->u.restore) + goto error_arg; + + heap_free(iter->stream_heap); + ret = heap_init(iter->stream_heap, 0, stream_compare); + if (ret < 0) + goto error; + + for (i = 0; i < iter_pos->u.restore->stream_saved_pos->len; + i++) { + struct stream_saved_pos *saved_pos; + struct ctf_stream_pos *stream_pos; + struct ctf_stream *stream; + + saved_pos = &g_array_index( + iter_pos->u.restore->stream_saved_pos, + struct stream_saved_pos, i); + stream = &saved_pos->file_stream->parent; + stream_pos = &saved_pos->file_stream->pos; + + stream_pos->packet_seek(&stream_pos->parent, + saved_pos->cur_index, SEEK_SET); + + /* + * the timestamp needs to be restored after + * packet_seek, because this function resets + * the timestamp to the beginning of the packet + */ + stream->timestamp = saved_pos->current_timestamp; + stream_pos->offset = saved_pos->offset; + stream_pos->last_offset = saved_pos->offset; + + stream->prev_timestamp = 0; + stream->prev_timestamp_end = 0; + stream->consumed = 0; + + printf_debug("restored to cur_index = %zd and " + "offset = %zd, timestamp = %" PRIu64 "\n", + stream_pos->cur_index, + stream_pos->offset, stream->timestamp); + + stream_read_event(saved_pos->file_stream); + + /* Add to heap */ + ret = heap_insert(iter->stream_heap, + saved_pos->file_stream); + if (ret) + goto error; + } + case BT_SEEK_TIME: + tc = iter->ctx->tc; + + if (!iter_pos->u.seek_time) + goto error_arg; + + heap_free(iter->stream_heap); + ret = heap_init(iter->stream_heap, 0, stream_compare); + if (ret < 0) + goto error; + + /* for each trace in the trace_collection */ + for (i = 0; i < tc->array->len; i++) { + struct ctf_trace *tin; + struct trace_descriptor *td_read; + + td_read = g_ptr_array_index(tc->array, i); + tin = container_of(td_read, struct ctf_trace, parent); + + ret = seek_ctf_trace_by_timestamp(tin, + iter_pos->u.seek_time, + iter->stream_heap); + if (ret < 0) + goto error; + } + return 0; + default: + /* not implemented */ + goto error_arg; + } + + return 0; + +error_arg: + ret = -EINVAL; +error: + heap_free(iter->stream_heap); + if (heap_init(iter->stream_heap, 0, stream_compare) < 0) { + heap_free(iter->stream_heap); + g_free(iter->stream_heap); + iter->stream_heap = NULL; + ret = -ENOMEM; + } + return ret; +} + +struct bt_iter_pos *bt_iter_get_pos(struct bt_iter *iter) +{ + struct bt_iter_pos *pos; + struct trace_collection *tc = iter->ctx->tc; + int i, stream_class_id, stream_id; + + pos = g_new0(struct bt_iter_pos, 1); + pos->u.restore = g_new0(struct bt_saved_pos, 1); + pos->u.restore->tc = tc; + pos->u.restore->stream_saved_pos = g_array_new(FALSE, TRUE, + sizeof(struct stream_saved_pos)); + if (!pos->u.restore->stream_saved_pos) + goto error; + + for (i = 0; i < tc->array->len; i++) { + struct ctf_trace *tin; + struct trace_descriptor *td_read; + + td_read = g_ptr_array_index(tc->array, i); + tin = container_of(td_read, struct ctf_trace, parent); + + for (stream_class_id = 0; stream_class_id < tin->streams->len; + stream_class_id++) { + struct ctf_stream_class *stream_class; + + stream_class = g_ptr_array_index(tin->streams, + stream_class_id); + for (stream_id = 0; + stream_id < stream_class->streams->len; + stream_id++) { + struct ctf_stream *stream; + struct ctf_file_stream *cfs; + struct stream_saved_pos saved_pos; + + stream = g_ptr_array_index( + stream_class->streams, + stream_id); + cfs = container_of(stream, + struct ctf_file_stream, + parent); + + saved_pos.file_stream = cfs; + saved_pos.cur_index = cfs->pos.cur_index; + + /* + * It is possible that an event was read during + * the last restore, never consumed and its + * position saved again. For this case, we + * need to check if the event really was + * consumed by the caller otherwise it is lost. + */ + if (stream->consumed) + saved_pos.offset = cfs->pos.offset; + else + saved_pos.offset = cfs->pos.last_offset; + + saved_pos.current_timestamp = stream->timestamp; + + g_array_append_val( + pos->u.restore->stream_saved_pos, + saved_pos); + + printf_debug("stream : %" PRIu64 ", cur_index : %zd, " + "offset : %zd, " + "timestamp = %" PRIu64 "\n", + stream->stream_id, saved_pos.cur_index, + saved_pos.offset, + saved_pos.current_timestamp); + } + } + } + + return pos; + +error: + return NULL; +} + +struct bt_iter_pos *bt_iter_create_time_pos(struct bt_iter *iter, + uint64_t timestamp) +{ + struct bt_iter_pos *pos; + + pos = g_new0(struct bt_iter_pos, 1); + pos->type = BT_SEEK_TIME; + pos->u.seek_time = timestamp; + return pos; +} + /* * babeltrace_filestream_seek: seek a filestream to given position. * @@ -88,7 +379,8 @@ static int babeltrace_filestream_seek(struct ctf_file_stream *file_stream, */ break; case BT_SEEK_BEGIN: - file_stream->pos.move_pos_slow(&file_stream->pos, 0, SEEK_SET); + file_stream->pos.packet_seek(&file_stream->pos.parent, + 0, SEEK_SET); ret = stream_read_event(file_stream); break; case BT_SEEK_TIME: @@ -142,25 +434,17 @@ end: return ret; } -struct bt_iter *bt_iter_create(struct bt_context *ctx, +int bt_iter_init(struct bt_iter *iter, + struct bt_context *ctx, struct bt_iter_pos *begin_pos, struct bt_iter_pos *end_pos) { int i, stream_id; int ret = 0; - struct bt_iter *iter; - iter = malloc(sizeof(struct bt_iter)); - if (!iter) - goto error_malloc; iter->stream_heap = g_new(struct ptr_heap, 1); iter->end_pos = end_pos; - iter->callbacks = g_array_new(0, 1, sizeof(struct bt_stream_callbacks)); - iter->recalculate_dep_graph = 0; - iter->main_callbacks.callback = NULL; - iter->dep_gc = g_ptr_array_new(); - if (bt_context_get(ctx) != 0) - goto error_ctx; + bt_context_get(ctx); iter->ctx = ctx; ret = heap_init(iter->stream_heap, 0, stream_compare); @@ -208,50 +492,44 @@ struct bt_iter *bt_iter_create(struct bt_context *ctx, } } - return iter; + return 0; error: heap_free(iter->stream_heap); error_heap_init: g_free(iter->stream_heap); -error_ctx: - free(iter); -error_malloc: - return NULL; + return ret; } -void bt_iter_destroy(struct bt_iter *iter) +struct bt_iter *bt_iter_create(struct bt_context *ctx, + struct bt_iter_pos *begin_pos, + struct bt_iter_pos *end_pos) { - struct bt_stream_callbacks *bt_stream_cb; - struct bt_callback_chain *bt_chain; - int i, j; - - heap_free(iter->stream_heap); - g_free(iter->stream_heap); - - /* free all events callbacks */ - if (iter->main_callbacks.callback) - g_array_free(iter->main_callbacks.callback, TRUE); + struct bt_iter *iter; + int ret; - /* free per-event callbacks */ - for (i = 0; i < iter->callbacks->len; i++) { - bt_stream_cb = &g_array_index(iter->callbacks, - struct bt_stream_callbacks, i); - if (!bt_stream_cb || !bt_stream_cb->per_id_callbacks) - continue; - for (j = 0; j < bt_stream_cb->per_id_callbacks->len; j++) { - bt_chain = &g_array_index(bt_stream_cb->per_id_callbacks, - struct bt_callback_chain, j); - if (bt_chain->callback) { - g_array_free(bt_chain->callback, TRUE); - } - } - g_array_free(bt_stream_cb->per_id_callbacks, TRUE); + iter = g_new0(struct bt_iter, 1); + ret = bt_iter_init(iter, ctx, begin_pos, end_pos); + if (ret) { + g_free(iter); + return NULL; } + return iter; +} +void bt_iter_fini(struct bt_iter *iter) +{ + if (iter->stream_heap) { + heap_free(iter->stream_heap); + g_free(iter->stream_heap); + } bt_context_put(iter->ctx); +} - free(iter); +void bt_iter_destroy(struct bt_iter *iter) +{ + bt_iter_fini(iter); + g_free(iter); } int bt_iter_next(struct bt_iter *iter) @@ -282,28 +560,3 @@ int bt_iter_next(struct bt_iter *iter) end: return ret; } - -int bt_iter_read_event(struct bt_iter *iter, - struct ctf_stream **stream, - struct ctf_stream_event **event) -{ - struct ctf_file_stream *file_stream; - int ret = 0; - - file_stream = heap_maximum(iter->stream_heap); - if (!file_stream) { - /* end of file for all streams */ - ret = EOF; - goto end; - } - *stream = &file_stream->parent; - *event = g_ptr_array_index((*stream)->events_by_id, (*stream)->event_id); - - if ((*stream)->stream_id > iter->callbacks->len) - goto end; - - process_callbacks(iter, *stream); - -end: - return ret; -}