X-Git-Url: http://git.efficios.com/?p=babeltrace.git;a=blobdiff_plain;f=converter%2Fbabeltrace-lib.c;h=e08c0ada0c0a87c4ac9dd40916f088cd1785b30d;hp=534e4eddd5e9ffa743b9f79dd46bdd3271863724;hb=13662adfea0ca5dc160a3b3ac69a4f59c4bf3494;hpb=0d0f514904a3ebb85775abceed30da0675f55cc6 diff --git a/converter/babeltrace-lib.c b/converter/babeltrace-lib.c index 534e4edd..e08c0ada 100644 --- a/converter/babeltrace-lib.c +++ b/converter/babeltrace-lib.c @@ -3,7 +3,9 @@ * * Babeltrace Trace Converter Library * - * Copyright 2010 - Mathieu Desnoyers + * Copyright 2010-2011 EfficiOS Inc. and Linux Foundation + * + * Author: Mathieu Desnoyers * * Permission is hereby granted, free of charge, to any person obtaining a copy * of this software and associated documentation files (the "Software"), to deal @@ -20,18 +22,31 @@ #include #include #include -#include +#include #include #include #include #include #include +#include +#include +#include +#include + +/* + * struct babeltrace_iter: data structure representing an iterator on a trace + * collection. + */ +struct babeltrace_iter { + struct ptr_heap *stream_heap; + struct trace_collection *tc; +}; -static int read_event(struct ctf_file_stream *sin) +static int stream_read_event(struct ctf_file_stream *sin) { int ret; - ret = sin->pos.parent.event_cb(&sin->pos.parent, &sin->stream); + ret = sin->pos.parent.event_cb(&sin->pos.parent, &sin->parent); if (ret == EOF) return EOF; else if (ret) { @@ -48,78 +63,156 @@ int stream_compare(void *a, void *b) { struct ctf_file_stream *s_a = a, *s_b = b; - if (s_a->stream.timestamp < s_b->stream.timestamp) + if (s_a->parent.timestamp < s_b->parent.timestamp) return 1; else return 0; } -int convert_trace(struct trace_descriptor *td_write, - struct trace_descriptor *td_read) +struct babeltrace_iter *babeltrace_iter_create(struct trace_collection *tc) { - struct ctf_trace *tin = container_of(td_read, struct ctf_trace, parent); - struct ctf_text_stream_pos *sout = - container_of(td_write, struct ctf_text_stream_pos, trace_descriptor); - int stream_id; + int i, stream_id; int ret = 0; + struct babeltrace_iter *iter; + + iter = malloc(sizeof(struct babeltrace_iter)); + if (!iter) + goto error_malloc; + iter->stream_heap = g_new(struct ptr_heap, 1); + iter->tc = tc; + + ret = heap_init(iter->stream_heap, 0, stream_compare); + if (ret < 0) + goto error_heap_init; + + 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); - tin->stream_heap = g_new(struct ptr_heap, 1); - heap_init(tin->stream_heap, 0, stream_compare); - - /* Populate heap with each stream */ - for (stream_id = 0; stream_id < tin->streams->len; stream_id++) { - struct ctf_stream_class *stream = g_ptr_array_index(tin->streams, stream_id); - int filenr; - - if (!stream) - continue; - for (filenr = 0; filenr < stream->files->len; filenr++) { - struct ctf_file_stream *file_stream = g_ptr_array_index(stream->files, filenr); - ret = read_event(file_stream); - if (ret == EOF) { - ret = 0; + /* Populate heap with each stream */ + for (stream_id = 0; stream_id < tin->streams->len; + stream_id++) { + struct ctf_stream_class *stream; + int filenr; + + stream = g_ptr_array_index(tin->streams, stream_id); + if (!stream) continue; - } else if (ret) - goto end; - /* Add to heap */ - ret = heap_insert(tin->stream_heap, file_stream); - if (ret) { - fprintf(stdout, "[error] Out of memory.\n"); - goto end; + for (filenr = 0; filenr < stream->streams->len; + filenr++) { + struct ctf_file_stream *file_stream; + + file_stream = g_ptr_array_index(stream->streams, + filenr); + + ret = stream_read_event(file_stream); + if (ret == EOF) { + ret = 0; + continue; + } else if (ret) { + goto error; + } + /* Add to heap */ + ret = heap_insert(iter->stream_heap, file_stream); + if (ret) + goto error; } } } - /* Replace heap entries until EOF for each stream (heap empty) */ - for (;;) { - struct ctf_file_stream *file_stream, *removed; + return iter; - file_stream = heap_maximum(tin->stream_heap); - if (!file_stream) { - /* end of file for all streams */ - ret = 0; - break; - } - ret = sout->parent.event_cb(&sout->parent, &file_stream->stream); +error: + heap_free(iter->stream_heap); +error_heap_init: + g_free(iter->stream_heap); + free(iter); +error_malloc: + return NULL; +} + +void babeltrace_iter_destroy(struct babeltrace_iter *iter) +{ + heap_free(iter->stream_heap); + g_free(iter->stream_heap); + free(iter); +} + +int babeltrace_iter_next(struct babeltrace_iter *iter) +{ + struct ctf_file_stream *file_stream, *removed; + int ret; + + file_stream = heap_maximum(iter->stream_heap); + if (!file_stream) { + /* end of file for all streams */ + ret = 0; + goto end; + } + + ret = stream_read_event(file_stream); + if (ret == EOF) { + removed = heap_remove(iter->stream_heap); + assert(removed == file_stream); + ret = 0; + goto end; + } else if (ret) { + goto end; + } + /* Reinsert the file stream into the heap, and rebalance. */ + removed = heap_replace_max(iter->stream_heap, file_stream); + assert(removed == file_stream); + +end: + return ret; +} + +int babeltrace_iter_read_event(struct babeltrace_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); +end: + return ret; +} + +int convert_trace(struct trace_descriptor *td_write, + struct trace_collection *trace_collection_read) +{ + struct babeltrace_iter *iter; + struct ctf_stream *stream; + struct ctf_stream_event *event; + struct ctf_text_stream_pos *sout; + int ret = 0; + + sout = container_of(td_write, struct ctf_text_stream_pos, + trace_descriptor); + + iter = babeltrace_iter_create(trace_collection_read); + while (babeltrace_iter_read_event(iter, &stream, &event) == 0) { + ret = sout->parent.event_cb(&sout->parent, stream); if (ret) { fprintf(stdout, "[error] Writing event failed.\n"); goto end; } - ret = read_event(file_stream); - if (ret == EOF) { - removed = heap_remove(tin->stream_heap); - assert(removed == file_stream); - ret = 0; - continue; - } else if (ret) + ret = babeltrace_iter_next(iter); + if (ret < 0) goto end; - /* Reinsert the file stream into the heap, and rebalance. */ - removed = heap_replace_max(tin->stream_heap, file_stream); - assert(removed == file_stream); } - end: - heap_free(tin->stream_heap); - g_free(tin->stream_heap); + babeltrace_iter_destroy(iter); return ret; }