X-Git-Url: http://git.efficios.com/?p=babeltrace.git;a=blobdiff_plain;f=lib%2Fiterator.c;h=41a46020f6c690b4cc253044d845c0919e34cf0f;hp=2dbd77c0df1ee1de769401f5e05e7102fd2b7142;hb=c462e188f3e7819c7bc74f671038cdbf36e8c3c0;hpb=28fcbaca77cdf7b7c34e19cb46e15a136ff5e397 diff --git a/lib/iterator.c b/lib/iterator.c index 2dbd77c0..41a46020 100644 --- a/lib/iterator.c +++ b/lib/iterator.c @@ -16,6 +16,14 @@ * * The above copyright notice and this permission notice shall be included in * all copies or substantial portions of the Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR + * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, + * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE + * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER + * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, + * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE + * SOFTWARE. */ #include @@ -103,6 +111,10 @@ void bt_iter_free_pos(struct bt_iter_pos *iter_pos) * * Return 0 if the seek succeded, EOF if we didn't find any packet * containing the timestamp, or a positive integer for error. + * + * TODO: this should be turned into a binary search! It is currently + * doing a linear search in the packets. This is a O(n) operation on a + * very frequent code path. */ static int seek_file_stream_by_timestamp(struct ctf_file_stream *cfs, uint64_t timestamp) @@ -187,6 +199,152 @@ static int seek_ctf_trace_by_timestamp(struct ctf_trace *tin, return found ? 0 : EOF; } +/* + * Find timestamp of last event in the stream. + * + * Return value: 0 if OK, positive error value on error, EOF if no + * events were found. + */ +static int find_max_timestamp_ctf_file_stream(struct ctf_file_stream *cfs, + uint64_t *timestamp_end) +{ + int ret, count = 0, i; + uint64_t timestamp = 0; + struct ctf_stream_pos *stream_pos; + + stream_pos = &cfs->pos; + /* + * We start by the last packet, and iterate backwards until we + * either find at least one event, or we reach the first packet + * (some packets can be empty). + */ + for (i = stream_pos->packet_real_index->len - 1; i >= 0; i--) { + stream_pos->packet_seek(&stream_pos->parent, i, SEEK_SET); + count = 0; + /* read each event until we reach the end of the stream */ + do { + ret = stream_read_event(cfs); + if (ret == 0) { + count++; + timestamp = cfs->parent.real_timestamp; + } + } while (ret == 0); + + /* Error */ + if (ret > 0) + goto end; + assert(ret == EOF); + if (count) + break; + } + + if (count) { + *timestamp_end = timestamp; + ret = 0; + } else { + /* Return EOF if no events were found */ + ret = EOF; + } +end: + return ret; +} + +/* + * Find the stream within a stream class that contains the event with + * the largest timestamp, and save that timestamp. + * + * Return 0 if OK, EOF if no events were found in the streams, or + * positive value on error. + */ +static int find_max_timestamp_ctf_stream_class( + struct ctf_stream_declaration *stream_class, + struct ctf_file_stream **cfsp, + uint64_t *max_timestamp) +{ + int ret = EOF, i, found = 0; + + for (i = 0; i < stream_class->streams->len; i++) { + struct ctf_stream_definition *stream; + struct ctf_file_stream *cfs; + uint64_t current_max_ts = 0; + + stream = g_ptr_array_index(stream_class->streams, i); + if (!stream) + continue; + cfs = container_of(stream, struct ctf_file_stream, parent); + ret = find_max_timestamp_ctf_file_stream(cfs, ¤t_max_ts); + if (ret == EOF) + continue; + if (ret != 0) + break; + if (current_max_ts >= *max_timestamp) { + *max_timestamp = current_max_ts; + *cfsp = cfs; + found = 1; + } + } + assert(ret >= 0 || ret == EOF); + if (found) { + return 0; + } + return ret; +} + +/* + * seek_last_ctf_trace_collection: seek trace collection to last event. + * + * Return 0 if OK, EOF if no events were found, or positive error value + * on error. + */ +static int seek_last_ctf_trace_collection(struct trace_collection *tc, + struct ctf_file_stream **cfsp) +{ + int i, j, ret; + int found = 0; + uint64_t max_timestamp = 0; + + if (!tc) + return 1; + + /* 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); + if (!td_read) + continue; + tin = container_of(td_read, struct ctf_trace, parent); + /* For each stream_class in the trace */ + for (j = 0; j < tin->streams->len; j++) { + struct ctf_stream_declaration *stream_class; + + stream_class = g_ptr_array_index(tin->streams, j); + if (!stream_class) + continue; + ret = find_max_timestamp_ctf_stream_class(stream_class, + cfsp, &max_timestamp); + if (ret > 0) + goto end; + if (ret == 0) + found = 1; + assert(ret == EOF || ret == 0); + } + } + /* + * Now we know in which file stream the last event is located, + * and we know its timestamp. + */ + if (!found) { + ret = EOF; + } else { + ret = seek_file_stream_by_timestamp(*cfsp, max_timestamp); + assert(ret == 0); + } +end: + return ret; +} + int bt_iter_set_pos(struct bt_iter *iter, const struct bt_iter_pos *iter_pos) { struct trace_collection *tc; @@ -235,8 +393,8 @@ int bt_iter_set_pos(struct bt_iter *iter, const struct bt_iter_pos *iter_pos) stream->prev_cycles_timestamp = 0; stream->prev_cycles_timestamp_end = 0; - printf_debug("restored to cur_index = %zd and " - "offset = %zd, timestamp = %" PRIu64 "\n", + printf_debug("restored to cur_index = %" PRId64 " and " + "offset = %" PRId64 ", timestamp = %" PRIu64 "\n", stream_pos->cur_index, stream_pos->offset, stream->real_timestamp); @@ -325,6 +483,10 @@ int bt_iter_set_pos(struct bt_iter *iter, const struct bt_iter_pos *iter_pos) if (ret != 0 && ret != EOF) { goto error; } + if (ret == EOF) { + /* Do not add EOF streams */ + continue; + } ret = heap_insert(iter->stream_heap, file_stream); if (ret) goto error; @@ -332,6 +494,26 @@ int bt_iter_set_pos(struct bt_iter *iter, const struct bt_iter_pos *iter_pos) } } break; + case BT_SEEK_LAST: + { + struct ctf_file_stream *cfs = NULL; + + tc = iter->ctx->tc; + ret = seek_last_ctf_trace_collection(tc, &cfs); + if (ret != 0 || !cfs) + goto error; + /* remove all streams from the heap */ + heap_free(iter->stream_heap); + /* Create a new empty heap */ + ret = heap_init(iter->stream_heap, 0, stream_compare); + if (ret < 0) + goto error; + /* Insert the stream that contains the last event */ + ret = heap_insert(iter->stream_heap, cfs); + if (ret) + goto error; + break; + } default: /* not implemented */ return -EINVAL; @@ -459,7 +641,6 @@ static int babeltrace_filestream_seek(struct ctf_file_stream *file_stream, break; case BT_SEEK_TIME: case BT_SEEK_RESTORE: - case BT_SEEK_END: default: assert(0); /* Not yet defined */ }