Merge real index and cycles index into a single index
authorMathieu Desnoyers <mathieu.desnoyers@efficios.com>
Wed, 29 Jan 2014 02:14:48 +0000 (21:14 -0500)
committerMathieu Desnoyers <mathieu.desnoyers@efficios.com>
Sat, 8 Feb 2014 15:38:54 +0000 (10:38 -0500)
Merge those two into a single index array, rather than having partially
duplicated data.

Signed-off-by: Mathieu Desnoyers <mathieu.desnoyers@efficios.com>
formats/ctf/ctf.c
formats/ctf/iterator.c
formats/lttng-live/lttng-live-functions.c
include/babeltrace/ctf/types.h
lib/iterator.c

index afc2aefae97c3aab8f0e81d94cf982c09b4ff9da..7d98eb7a8f9ae61cd055ccea6ed37b95f20600f6 100644 (file)
@@ -181,26 +181,24 @@ uint64_t ctf_timestamp_begin(struct bt_trace_descriptor *descriptor,
                                        parent);
                        stream_pos = &cfs->pos;
 
-                       if (!stream_pos->packet_real_index)
+                       if (!stream_pos->packet_index)
                                goto error;
 
-                       if (stream_pos->packet_real_index->len <= 0)
+                       if (stream_pos->packet_index->len <= 0)
                                continue;
 
+                       index = &g_array_index(stream_pos->packet_index,
+                                       struct packet_index,
+                                       stream_pos->packet_index->len - 1);
                        if (type == BT_CLOCK_REAL) {
-                               index = &g_array_index(stream_pos->packet_real_index,
-                                               struct packet_index,
-                                               stream_pos->packet_real_index->len - 1);
+                               if (index->ts_real.timestamp_begin < begin)
+                                       begin = index->ts_real.timestamp_begin;
                        } else if (type == BT_CLOCK_CYCLES) {
-                               index = &g_array_index(stream_pos->packet_cycles_index,
-                                               struct packet_index,
-                                               stream_pos->packet_real_index->len - 1);
-
+                               if (index->ts_cycles.timestamp_begin < begin)
+                                       begin = index->ts_cycles.timestamp_begin;
                        } else {
                                goto error;
                        }
-                       if (index->timestamp_begin < begin)
-                               begin = index->timestamp_begin;
                }
        }
 
@@ -242,26 +240,24 @@ uint64_t ctf_timestamp_end(struct bt_trace_descriptor *descriptor,
                                        parent);
                        stream_pos = &cfs->pos;
 
-                       if (!stream_pos->packet_real_index)
+                       if (!stream_pos->packet_index)
                                goto error;
 
-                       if (stream_pos->packet_real_index->len <= 0)
+                       if (stream_pos->packet_index->len <= 0)
                                continue;
 
+                       index = &g_array_index(stream_pos->packet_index,
+                                       struct packet_index,
+                                       stream_pos->packet_index->len - 1);
                        if (type == BT_CLOCK_REAL) {
-                               index = &g_array_index(stream_pos->packet_real_index,
-                                               struct packet_index,
-                                               stream_pos->packet_real_index->len - 1);
+                               if (index->ts_real.timestamp_end > end)
+                                       end = index->ts_real.timestamp_end;
                        } else if (type == BT_CLOCK_CYCLES) {
-                               index = &g_array_index(stream_pos->packet_cycles_index,
-                                               struct packet_index,
-                                               stream_pos->packet_real_index->len - 1);
-
+                               if (index->ts_cycles.timestamp_end > end)
+                                       end = index->ts_cycles.timestamp_end;
                        } else {
                                goto error;
                        }
-                       if (index->timestamp_end > end)
-                               end = index->timestamp_end;
                }
        }
 
@@ -737,13 +733,10 @@ int ctf_init_pos(struct ctf_stream_pos *pos, struct bt_trace_descriptor *trace,
 {
        pos->fd = fd;
        if (fd >= 0) {
-               pos->packet_cycles_index = g_array_new(FALSE, TRUE,
-                                               sizeof(struct packet_index));
-               pos->packet_real_index = g_array_new(FALSE, TRUE,
+               pos->packet_index = g_array_new(FALSE, TRUE,
                                sizeof(struct packet_index));
        } else {
-               pos->packet_cycles_index = NULL;
-               pos->packet_real_index = NULL;
+               pos->packet_index = NULL;
        }
        switch (open_flags & O_ACCMODE) {
        case O_RDONLY:
@@ -783,10 +776,8 @@ int ctf_fini_pos(struct ctf_stream_pos *pos)
                        return -1;
                }
        }
-       if (pos->packet_cycles_index)
-               (void) g_array_free(pos->packet_cycles_index, TRUE);
-       if (pos->packet_real_index)
-               (void) g_array_free(pos->packet_real_index, TRUE);
+       if (pos->packet_index)
+               (void) g_array_free(pos->packet_index, TRUE);
        return 0;
 }
 
@@ -859,27 +850,23 @@ void ctf_packet_seek(struct bt_stream_pos *stream_pos, size_t index, int whence)
                        if (pos->offset == EOF) {
                                return;
                        }
-                       assert(pos->cur_index < pos->packet_cycles_index->len);
-                       assert(pos->cur_index < pos->packet_real_index->len);
+                       assert(pos->cur_index < pos->packet_index->len);
 
                        /* For printing discarded event count */
-                       packet_index = &g_array_index(pos->packet_cycles_index,
+                       packet_index = &g_array_index(pos->packet_index,
                                        struct packet_index, pos->cur_index);
                        file_stream->parent.prev_cycles_timestamp_end =
-                               packet_index->timestamp_end;
+                                       packet_index->ts_cycles.timestamp_end;
                        file_stream->parent.prev_cycles_timestamp =
-                               packet_index->timestamp_begin;
-
-                       packet_index = &g_array_index(pos->packet_real_index,
-                                       struct packet_index, pos->cur_index);
+                                       packet_index->ts_cycles.timestamp_begin;
                        file_stream->parent.prev_real_timestamp_end =
-                                               packet_index->timestamp_end;
+                                       packet_index->ts_real.timestamp_end;
                        file_stream->parent.prev_real_timestamp =
-                               packet_index->timestamp_begin;
+                                       packet_index->ts_real.timestamp_begin;
 
                        events_discarded_diff = packet_index->events_discarded;
                        if (pos->cur_index > 0) {
-                               packet_index = &g_array_index(pos->packet_real_index,
+                               packet_index = &g_array_index(pos->packet_index,
                                                struct packet_index,
                                                pos->cur_index - 1);
                                events_discarded_diff -= packet_index->events_discarded;
@@ -899,11 +886,11 @@ void ctf_packet_seek(struct bt_stream_pos *stream_pos, size_t index, int whence)
                        break;
                }
                case SEEK_SET:
-                       if (index >= pos->packet_cycles_index->len) {
+                       if (index >= pos->packet_index->len) {
                                pos->offset = EOF;
                                return;
                        }
-                       packet_index = &g_array_index(pos->packet_cycles_index,
+                       packet_index = &g_array_index(pos->packet_index,
                                        struct packet_index, index);
                        pos->last_events_discarded = packet_index->events_discarded;
                        pos->cur_index = index;
@@ -915,7 +902,7 @@ void ctf_packet_seek(struct bt_stream_pos *stream_pos, size_t index, int whence)
                default:
                        assert(0);
                }
-               if (pos->cur_index >= pos->packet_real_index->len) {
+               if (pos->cur_index >= pos->packet_index->len) {
                        /*
                         * We need to check if we are in trace read or
                         * called from packet indexing.  In this last
@@ -941,15 +928,12 @@ void ctf_packet_seek(struct bt_stream_pos *stream_pos, size_t index, int whence)
                        pos->offset = EOF;
                        return;
                }
-               packet_index = &g_array_index(pos->packet_cycles_index,
+               packet_index = &g_array_index(pos->packet_index,
                                struct packet_index,
                                pos->cur_index);
-               file_stream->parent.cycles_timestamp = packet_index->timestamp_begin;
+               file_stream->parent.cycles_timestamp = packet_index->ts_cycles.timestamp_begin;
 
-               packet_index = &g_array_index(pos->packet_real_index,
-                               struct packet_index,
-                               pos->cur_index);
-               file_stream->parent.real_timestamp = packet_index->timestamp_begin;
+               file_stream->parent.real_timestamp = packet_index->ts_real.timestamp_begin;
 
                /* Lookup context/packet size in index */
                if (packet_index->data_offset == -1) {
@@ -1523,8 +1507,10 @@ begin:
        packet_index.offset = pos->mmap_offset;
        packet_index.content_size = 0;
        packet_index.packet_size = 0;
-       packet_index.timestamp_begin = 0;
-       packet_index.timestamp_end = 0;
+       packet_index.ts_real.timestamp_begin = 0;
+       packet_index.ts_real.timestamp_end = 0;
+       packet_index.ts_cycles.timestamp_begin = 0;
+       packet_index.ts_cycles.timestamp_end = 0;
        packet_index.events_discarded = 0;
        packet_index.events_discarded_len = 0;
 
@@ -1548,7 +1534,7 @@ begin:
                        if (magic != CTF_MAGIC) {
                                fprintf(stderr, "[error] Invalid magic number 0x%" PRIX64 " at packet %u (file offset %zd).\n",
                                                magic,
-                                               file_stream->pos.packet_cycles_index->len,
+                                               file_stream->pos.packet_index->len,
                                                (ssize_t) pos->mmap_offset);
                                return -EINVAL;
                        }
@@ -1640,12 +1626,12 @@ begin:
                        struct bt_definition *field;
 
                        field = bt_struct_definition_get_field_from_index(file_stream->parent.stream_packet_context, len_index);
-                       packet_index.timestamp_begin = bt_get_unsigned_int(field);
+                       packet_index.ts_cycles.timestamp_begin = bt_get_unsigned_int(field);
                        if (file_stream->parent.stream_class->trace->parent.collection) {
-                               packet_index.timestamp_begin =
+                               packet_index.ts_real.timestamp_begin =
                                        ctf_get_real_timestamp(
                                                &file_stream->parent,
-                                               packet_index.timestamp_begin);
+                                               packet_index.ts_cycles.timestamp_begin);
                        }
                }
 
@@ -1655,12 +1641,12 @@ begin:
                        struct bt_definition *field;
 
                        field = bt_struct_definition_get_field_from_index(file_stream->parent.stream_packet_context, len_index);
-                       packet_index.timestamp_end = bt_get_unsigned_int(field);
+                       packet_index.ts_cycles.timestamp_end = bt_get_unsigned_int(field);
                        if (file_stream->parent.stream_class->trace->parent.collection) {
-                               packet_index.timestamp_end =
+                               packet_index.ts_real.timestamp_end =
                                        ctf_get_real_timestamp(
                                                &file_stream->parent,
-                                               packet_index.timestamp_end);
+                                               packet_index.ts_cycles.timestamp_end);
                        }
                }
 
@@ -1707,7 +1693,7 @@ begin:
        packet_index.data_offset = pos->offset;
 
        /* add index to packet array */
-       g_array_append_val(file_stream->pos.packet_cycles_index, packet_index);
+       g_array_append_val(file_stream->pos.packet_index, packet_index);
 
        pos->mmap_offset += packet_index.packet_size >> LOG2_CHAR_BIT;
 
@@ -1855,8 +1841,8 @@ int import_stream_packet_index(struct ctf_trace *td,
                index.offset = be64toh(ctf_index.offset);
                index.packet_size = be64toh(ctf_index.packet_size);
                index.content_size = be64toh(ctf_index.content_size);
-               index.timestamp_begin = be64toh(ctf_index.timestamp_begin);
-               index.timestamp_end = be64toh(ctf_index.timestamp_end);
+               index.ts_cycles.timestamp_begin = be64toh(ctf_index.timestamp_begin);
+               index.ts_cycles.timestamp_end = be64toh(ctf_index.timestamp_end);
                index.events_discarded = be64toh(ctf_index.events_discarded);
                index.events_discarded_len = 64;
                index.data_offset = -1;
@@ -1864,7 +1850,7 @@ int import_stream_packet_index(struct ctf_trace *td,
 
                if (!first_packet) {
                        /* add index to packet array */
-                       g_array_append_val(file_stream->pos.packet_cycles_index, index);
+                       g_array_append_val(file_stream->pos.packet_index, index);
                        continue;
                }
 
@@ -1883,7 +1869,7 @@ int import_stream_packet_index(struct ctf_trace *td,
                        goto error;
                first_packet = 0;
                /* add index to packet array */
-               g_array_append_val(file_stream->pos.packet_cycles_index, index);
+               g_array_append_val(file_stream->pos.packet_index, index);
        }
 
        /* Index containing only the header. */
@@ -2193,8 +2179,7 @@ void ctf_init_mmap_pos(struct ctf_stream_pos *pos,
        pos->offset = 0;
        pos->dummy = false;
        pos->cur_index = 0;
-       pos->packet_cycles_index = NULL;
-       pos->packet_real_index = NULL;
+       pos->packet_index = NULL;
        pos->prot = PROT_READ;
        pos->flags = MAP_PRIVATE;
        pos->parent.rw_table = read_dispatch_table;
@@ -2362,25 +2347,20 @@ int ctf_convert_index_timestamp(struct bt_trace_descriptor *tdp)
                        cfs = container_of(stream, struct ctf_file_stream,
                                        parent);
                        stream_pos = &cfs->pos;
-                       if (!stream_pos->packet_cycles_index)
+                       if (!stream_pos->packet_index)
                                continue;
 
-                       for (k = 0; k < stream_pos->packet_cycles_index->len; k++) {
+                       for (k = 0; k < stream_pos->packet_index->len; k++) {
                                struct packet_index *index;
-                               struct packet_index new_index;
 
-                               index = &g_array_index(stream_pos->packet_cycles_index,
+                               index = &g_array_index(stream_pos->packet_index,
                                                struct packet_index, k);
-                               memcpy(&new_index, index,
-                                               sizeof(struct packet_index));
-                               new_index.timestamp_begin =
+                               index->ts_real.timestamp_begin =
                                        ctf_get_real_timestamp(stream,
-                                                       index->timestamp_begin);
-                               new_index.timestamp_end =
+                                                       index->ts_cycles.timestamp_begin);
+                               index->ts_real.timestamp_end =
                                        ctf_get_real_timestamp(stream,
-                                                       index->timestamp_end);
-                               g_array_append_val(stream_pos->packet_real_index,
-                                               new_index);
+                                                       index->ts_cycles.timestamp_end);
                        }
                }
        }
index 69bb0f4b7c513ff7b0bd9c8b07ad7cd9669c62f0..e5d32a890b503220a9ecefde2c31ae8464b12030 100644 (file)
@@ -152,10 +152,10 @@ struct bt_ctf_event *bt_ctf_iter_read_event_flags(struct bt_ctf_iter *iter,
        ret->parent = g_ptr_array_index(stream->events_by_id,
                        stream->event_id);
 
-       if (!file_stream->pos.packet_cycles_index)
+       if (!file_stream->pos.packet_index)
                packet_index = NULL;
        else
-               packet_index = &g_array_index(file_stream->pos.packet_cycles_index,
+               packet_index = &g_array_index(file_stream->pos.packet_index,
                                struct packet_index, file_stream->pos.cur_index);
        iter->events_lost = 0;
        if (packet_index && packet_index->events_discarded >
index 1f4b4dbc6ff3941bf6d1df767655869ef83daa30..375a05edeafd52b468a4f1b61709641eb7f99ec5 100644 (file)
@@ -722,7 +722,7 @@ retry:
        case LTTNG_VIEWER_INDEX_INACTIVE:
                printf_verbose("get_next_index: inactive\n");
                memset(index, 0, sizeof(struct packet_index));
-               index->timestamp_end = be64toh(rp.timestamp_end);
+               index->ts_cycles.timestamp_end = be64toh(rp.timestamp_end);
                break;
        case LTTNG_VIEWER_INDEX_OK:
                printf_verbose("get_next_index: Ok, need metadata update : %u\n",
@@ -730,8 +730,8 @@ retry:
                index->offset = be64toh(rp.offset);
                index->packet_size = be64toh(rp.packet_size);
                index->content_size = be64toh(rp.content_size);
-               index->timestamp_begin = be64toh(rp.timestamp_begin);
-               index->timestamp_end = be64toh(rp.timestamp_end);
+               index->ts_cycles.timestamp_begin = be64toh(rp.timestamp_begin);
+               index->ts_cycles.timestamp_end = be64toh(rp.timestamp_end);
                index->events_discarded = be64toh(rp.events_discarded);
 
                if (rp.flags & LTTNG_VIEWER_FLAG_NEW_METADATA) {
@@ -803,13 +803,13 @@ retry:
        }
 
        if (packet_index.content_size == 0) {
-               file_stream->parent.cycles_timestamp = packet_index.timestamp_end;
+               file_stream->parent.cycles_timestamp = packet_index.ts_cycles.timestamp_end;
                file_stream->parent.real_timestamp = ctf_get_real_timestamp(
-                               &file_stream->parent, packet_index.timestamp_end);
+                               &file_stream->parent, packet_index.ts_cycles.timestamp_end);
        } else {
-               file_stream->parent.cycles_timestamp = packet_index.timestamp_begin;
+               file_stream->parent.cycles_timestamp = packet_index.ts_cycles.timestamp_begin;
                file_stream->parent.real_timestamp = ctf_get_real_timestamp(
-                               &file_stream->parent, packet_index.timestamp_begin);
+                               &file_stream->parent, packet_index.ts_cycles.timestamp_begin);
        }
 
        if (pos->packet_size == 0 || pos->offset == EOF) {
@@ -833,7 +833,8 @@ retry:
                        ", offset %" PRIu64 ", content_size %" PRIu64
                        ", timestamp_end : %" PRIu64 "\n",
                        packet_index.packet_size, packet_index.offset,
-                       packet_index.content_size, packet_index.timestamp_end);
+                       packet_index.content_size,
+                       packet_index.ts_cycles.timestamp_end);
 
        /* update trace_packet_header and stream_packet_context */
        if (pos->prot != PROT_WRITE && file_stream->parent.trace_packet_header) {
index 338dad167ec976248c23a65c16b93973b9f44518..f268e13aa7fd412984332c143b111db208b86844 100644 (file)
 
 struct bt_stream_callbacks;
 
+struct packet_index_time {
+       uint64_t timestamp_begin;
+       uint64_t timestamp_end;
+};
+
 struct packet_index {
        off_t offset;           /* offset of the packet in the file, in bytes */
        int64_t data_offset;    /* offset of data within the packet, in bits */
        uint64_t packet_size;   /* packet size, in bits */
        uint64_t content_size;  /* content size, in bits */
-       uint64_t timestamp_begin;
-       uint64_t timestamp_end;
        uint64_t events_discarded;
        uint64_t events_discarded_len;  /* length of the field, in bits */
+       struct packet_index_time ts_cycles;     /* timestamp in cycles */
+       struct packet_index_time ts_real;       /* realtime timestamp */
 };
 
 /*
@@ -62,8 +67,7 @@ struct ctf_stream_pos {
        struct bt_stream_pos parent;
        int fd;                 /* backing file fd. -1 if unset. */
        FILE *index_fp;         /* backing index file fp. NULL if unset. */
-       GArray *packet_cycles_index;    /* contains struct packet_index in cycles */
-       GArray *packet_real_index;      /* contains struct packet_index in ns */
+       GArray *packet_index;   /* contains struct packet_index */
        int prot;               /* mmap protection */
        int flags;              /* mmap flags */
 
index 48c67a4031fb07167d61233a17b66b11f58df964..fd58dec99ce45dc4e8a682220d20ebf3a6edb3dc 100644 (file)
@@ -135,10 +135,10 @@ static int seek_file_stream_by_timestamp(struct ctf_file_stream *cfs,
        int i, ret;
 
        stream_pos = &cfs->pos;
-       for (i = 0; i < stream_pos->packet_real_index->len; i++) {
-               index = &g_array_index(stream_pos->packet_real_index,
+       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_end < timestamp)
+               if (index->ts_real.timestamp_end < timestamp)
                        continue;
 
                stream_pos->packet_seek(&stream_pos->parent, i, SEEK_SET);
@@ -229,7 +229,7 @@ static int find_max_timestamp_ctf_file_stream(struct ctf_file_stream *cfs,
         * 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--) {
+       for (i = stream_pos->packet_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 */
This page took 0.050663 seconds and 4 git commands to generate.