* SOFTWARE.
*/
-#include <babeltrace/common-internal.h>
-#include <babeltrace/babeltrace.h>
-#include <babeltrace/compat/uuid-internal.h>
+#include <babeltrace2/common-internal.h>
+#include <babeltrace2/babeltrace.h>
+#include <babeltrace2/compat/uuid-internal.h>
#include <plugins-common.h>
#include <glib.h>
-#include <babeltrace/assert-internal.h>
+#include <babeltrace2/assert-internal.h>
#include <inttypes.h>
#include <stdbool.h>
#include "fs.h"
g_string_free(ds_file_info->path, TRUE);
}
- ctf_fs_ds_index_destroy(ds_file_info->index);
g_free(ds_file_info);
}
static
struct ctf_fs_ds_file_info *ctf_fs_ds_file_info_create(const char *path,
- int64_t begin_ns, struct ctf_fs_ds_index *index)
+ int64_t begin_ns)
{
struct ctf_fs_ds_file_info *ds_file_info;
}
ds_file_info->begin_ns = begin_ns;
- ds_file_info->index = index;
- index = NULL;
end:
- ctf_fs_ds_index_destroy(index);
return ds_file_info;
}
g_ptr_array_free(ds_file_group->ds_file_infos, TRUE);
}
+ if (ds_file_group->index) {
+ if (ds_file_group->index->entries) {
+ g_ptr_array_free(ds_file_group->index->entries, TRUE);
+ }
+ g_free(ds_file_group->index);
+ }
+
bt_stream_put_ref(ds_file_group->stream);
g_free(ds_file_group);
}
struct ctf_fs_ds_file_group *ctf_fs_ds_file_group_create(
struct ctf_fs_trace *ctf_fs_trace,
struct ctf_stream_class *sc,
- uint64_t stream_instance_id)
+ uint64_t stream_instance_id,
+ struct ctf_fs_ds_index *index)
{
struct ctf_fs_ds_file_group *ds_file_group;
goto error;
}
+ ds_file_group->index = index;
+
ds_file_group->stream_id = stream_instance_id;
BT_ASSERT(sc);
ds_file_group->sc = sc;
error:
ctf_fs_ds_file_group_destroy(ds_file_group);
+ ctf_fs_ds_index_destroy(index);
ds_file_group = NULL;
end:
array_insert(ds_file_group->ds_file_infos, ds_file_info, i);
}
+static
+void ds_file_group_insert_ds_index_entry_sorted(
+ struct ctf_fs_ds_file_group *ds_file_group,
+ struct ctf_fs_ds_index_entry *entry)
+{
+ guint i;
+
+ /* Find the spot where to insert this index entry. */
+ for (i = 0; i < ds_file_group->index->entries->len; i++) {
+ struct ctf_fs_ds_index_entry *other_entry = g_ptr_array_index(
+ ds_file_group->index->entries, i);
+
+ if (entry->timestamp_begin_ns < other_entry->timestamp_begin_ns) {
+ break;
+ }
+ }
+
+ array_insert(ds_file_group->index->entries, entry, i);
+}
+
/*
* Create a new ds_file_info using the provided path, begin_ns and index, then
* add it to ds_file_group's list of ds_file_infos.
static
int ctf_fs_ds_file_group_add_ds_file_info(
struct ctf_fs_ds_file_group *ds_file_group,
- const char *path, int64_t begin_ns,
- struct ctf_fs_ds_index *index)
+ const char *path, int64_t begin_ns)
{
struct ctf_fs_ds_file_info *ds_file_info;
int ret = 0;
- /* Onwership of index is transferred. */
- ds_file_info = ctf_fs_ds_file_info_create(path, begin_ns, index);
- index = NULL;
+ ds_file_info = ctf_fs_ds_file_info_create(path, begin_ns);
if (!ds_file_info) {
goto error;
}
error:
ctf_fs_ds_file_info_destroy(ds_file_info);
- ctf_fs_ds_index_destroy(index);
ret = -1;
end:
return ret;
* group.
*/
ds_file_group = ctf_fs_ds_file_group_create(ctf_fs_trace,
- sc, UINT64_C(-1));
+ sc, UINT64_C(-1), index);
+ /* Ownership of index is transferred. */
+ index = NULL;
+
if (!ds_file_group) {
goto error;
}
ret = ctf_fs_ds_file_group_add_ds_file_info(ds_file_group,
- path, begin_ns, index);
- /* Ownership of index is transferred. */
- index = NULL;
+ path, begin_ns);
if (ret) {
goto error;
}
if (!ds_file_group) {
ds_file_group = ctf_fs_ds_file_group_create(ctf_fs_trace,
- sc, stream_instance_id);
+ sc, stream_instance_id, index);
+ /* Ownership of index is transferred. */
+ index = NULL;
if (!ds_file_group) {
goto error;
}
}
ret = ctf_fs_ds_file_group_add_ds_file_info(ds_file_group, path,
- begin_ns, index);
- index = NULL;
+ begin_ns);
if (ret) {
goto error;
}
ds_file_group_insert_ds_file_info_sorted(dest, ds_file_info);
}
-}
+ /* Merge both indexes. */
+ for (i = 0; i < src->index->entries->len; i++) {
+ struct ctf_fs_ds_index_entry *entry = g_ptr_array_index(
+ src->index->entries, i);
+
+ /*
+ * Ownership of the ctf_fs_ds_index_entry is transferred to
+ * dest.
+ */
+ g_ptr_array_index(src->index->entries, i) = NULL;
+
+ ds_file_group_insert_ds_index_entry_sorted(dest, entry);
+ }
+}
/* Merge src_trace's data stream file groups into dest_trace's. */
static
-void merge_matching_ctf_fs_ds_file_groups(
+int merge_matching_ctf_fs_ds_file_groups(
struct ctf_fs_trace *dest_trace,
struct ctf_fs_trace *src_trace)
{
GPtrArray *dest = dest_trace->ds_file_groups;
GPtrArray *src = src_trace->ds_file_groups;
guint s_i;
+ int ret = 0;
/*
* Save the initial length of dest: we only want to check against the
/*
* Didn't find a friend in dest to merge our src_group into?
- * Create a new empty one.
+ * Create a new empty one. This can happen if a stream was
+ * active in the source trace chunk but not in the destination
+ * trace chunk.
*/
if (!dest_group) {
struct ctf_stream_class *sc;
+ struct ctf_fs_ds_index *index;
sc = ctf_trace_class_borrow_stream_class_by_id(
dest_trace->metadata->tc, src_group->sc->id);
BT_ASSERT(sc);
+ index = ctf_fs_ds_index_create();
+ if (!index) {
+ ret = -1;
+ goto end;
+ }
+
dest_group = ctf_fs_ds_file_group_create(dest_trace, sc,
- src_group->stream_id);
+ src_group->stream_id, index);
+ /* Ownership of index is transferred. */
+ index = NULL;
+ if (!dest_group) {
+ ret = -1;
+ goto end;
+ }
g_ptr_array_add(dest_trace->ds_file_groups, dest_group);
}
BT_ASSERT(dest_group);
merge_ctf_fs_ds_file_groups(dest_group, src_group);
}
+
+end:
+ return ret;
}
/*
*/
static
-void merge_ctf_fs_traces(struct ctf_fs_trace **traces, unsigned int num_traces)
+int merge_ctf_fs_traces(struct ctf_fs_trace **traces, unsigned int num_traces)
{
unsigned int winner_count;
struct ctf_fs_trace *winner;
guint i;
+ int ret = 0;
char uuid_str[BABELTRACE_UUID_STR_LEN];
BT_ASSERT(num_traces >= 2);
}
/* Merge trace's data stream file groups into winner's. */
- merge_matching_ctf_fs_ds_file_groups(winner, trace);
+ ret = merge_matching_ctf_fs_ds_file_groups(winner, trace);
+ if (ret) {
+ goto end;
+ }
/* Free the trace that got merged into winner, clear the slot in the array. */
ctf_fs_trace_destroy(trace);
/* Use the string representation of the UUID as the trace name. */
bt_uuid_unparse(winner->metadata->tc->uuid, uuid_str);
g_string_printf(winner->name, "%s", uuid_str);
+
+end:
+ return ret;
}
/*
*/
static
-void merge_traces_with_same_uuid(struct ctf_fs_component *ctf_fs)
+int merge_traces_with_same_uuid(struct ctf_fs_component *ctf_fs)
{
GPtrArray *traces = ctf_fs->traces;
guint range_start_idx = 0;
unsigned int num_traces = 0;
guint i;
+ int ret = 0;
/* Sort the traces by uuid, then collapse traces with the same uuid in a single one. */
g_ptr_array_sort(traces, sort_traces_by_uuid);
range_len = range_end_exc_idx - range_start_idx;
if (range_len > 1) {
struct ctf_fs_trace **range_start = (struct ctf_fs_trace **) &traces->pdata[range_start_idx];
- merge_ctf_fs_traces(range_start, range_len);
+ ret = merge_ctf_fs_traces(range_start, range_len);
+ if (ret) {
+ goto end;
+ }
}
num_traces++;
}
BT_ASSERT(num_traces == traces->len);
+
+end:
+ return ret;
}
int ctf_fs_component_create_ctf_fs_traces(bt_self_component_source *self_comp,
}
}
- merge_traces_with_same_uuid(ctf_fs);
+ ret = merge_traces_with_same_uuid(ctf_fs);
end:
return ret;
projects / babeltrace.git / blobdiff