From 87148dc74de9861a656aa4f38f03b51743471049 Mon Sep 17 00:00:00 2001 From: Mathieu Desnoyers Date: Sat, 23 Mar 2013 13:13:52 -0400 Subject: [PATCH] Improvement: Message from babeltrace concerning discarded events needs improvement New output example: [warning] Tracer discarded 18508 events between [13:07:22.210641404] and [13:07:22.210642166] in trace UUID 857bd6395891954ab9d3defb2aeb98f7, at path: "/home/compudj/lttng-traces/auto-20130323-130705/kernel", within stream id 0, at relative path: "channel0_1". You should consider recording a new trace with larger buffers or with fewer events enabled. Fixes #469 Signed-off-by: Mathieu Desnoyers --- formats/ctf-text/ctf-text.c | 18 +---- formats/ctf/ctf.c | 89 +++++++++++++++--------- include/babeltrace/ctf-ir/metadata.h | 1 + include/babeltrace/ctf/events-internal.h | 2 + 4 files changed, 61 insertions(+), 49 deletions(-) diff --git a/formats/ctf-text/ctf-text.c b/formats/ctf-text/ctf-text.c index 0859378e..f60fde62 100644 --- a/formats/ctf-text/ctf-text.c +++ b/formats/ctf-text/ctf-text.c @@ -265,23 +265,7 @@ int ctf_text_write_event(struct bt_stream_pos *ppos, struct ctf_stream_definitio /* Print events discarded */ if (stream->events_discarded) { fflush(pos->fp); - fprintf(stderr, "[warning] Tracer discarded %" PRIu64 " events between [", - stream->events_discarded); - if (opt_clock_cycles) { - ctf_print_timestamp(stderr, stream, - stream->prev_cycles_timestamp); - fprintf(stderr, "] and ["); - ctf_print_timestamp(stderr, stream, - stream->prev_cycles_timestamp_end); - } else { - ctf_print_timestamp(stderr, stream, - stream->prev_real_timestamp); - fprintf(stderr, "] and ["); - ctf_print_timestamp(stderr, stream, - stream->prev_real_timestamp_end); - } - fprintf(stderr, "]. You should consider recording a new trace with larger buffers or with fewer events enabled.\n"); - fflush(stderr); + ctf_print_discarded(stderr, stream); stream->events_discarded = 0; } diff --git a/formats/ctf/ctf.c b/formats/ctf/ctf.c index 7c1ef735..8f8af525 100644 --- a/formats/ctf/ctf.c +++ b/formats/ctf/ctf.c @@ -391,6 +391,47 @@ void ctf_print_timestamp(FILE *fp, } } +static +void print_uuid(FILE *fp, unsigned char *uuid) +{ + int i; + + for (i = 0; i < BABELTRACE_UUID_LEN; i++) + fprintf(fp, "%x", (unsigned int) uuid[i]); +} + +void ctf_print_discarded(FILE *fp, struct ctf_stream_definition *stream) +{ + fprintf(fp, "[warning] Tracer discarded %" PRIu64 " events between [", + stream->events_discarded); + if (opt_clock_cycles) { + ctf_print_timestamp(fp, stream, + stream->prev_cycles_timestamp); + fprintf(fp, "] and ["); + ctf_print_timestamp(fp, stream, + stream->prev_cycles_timestamp_end); + } else { + ctf_print_timestamp(fp, stream, + stream->prev_real_timestamp); + fprintf(fp, "] and ["); + ctf_print_timestamp(fp, stream, + stream->prev_real_timestamp_end); + } + fprintf(fp, "] in trace UUID "); + print_uuid(fp, stream->stream_class->trace->uuid); + if (stream->stream_class->trace->path[0]) + fprintf(fp, ", at path: \"%s\"", + stream->stream_class->trace->path); + + fprintf(fp, ", within stream id %" PRIu64, stream->stream_id); + if (stream->path[0]) + fprintf(fp, ", at relative path: \"%s\"", stream->path); + fprintf(fp, ". "); + fprintf(fp, "You should consider recording a new trace with larger " + "buffers or with fewer events enabled.\n"); + fflush(fp); +} + static int ctf_read_event(struct bt_stream_pos *ppos, struct ctf_stream_definition *stream) { @@ -725,43 +766,24 @@ void ctf_packet_seek(struct bt_stream_pos *stream_pos, size_t index, int whence) } if (pos->cur_index >= pos->packet_real_index->len) { /* - * When a stream reaches the end of the - * file, we need to show the number of - * events discarded ourselves, because - * there is no next event scheduled to - * be printed in the output. + * We need to check if we are in trace read or + * called from packet indexing. In this last + * case, the collection is not there, so we + * cannot print the timestamps. */ - if (file_stream->parent.events_discarded) { + if ((&file_stream->parent)->stream_class->trace->collection) { /* - * We need to check if we are in trace - * read or called from packet indexing. - * In this last case, the collection is - * not there, so we cannot print the - * timestamps. + * When a stream reaches the end of the + * file, we need to show the number of + * events discarded ourselves, because + * there is no next event scheduled to + * be printed in the output. */ - if ((&file_stream->parent)->stream_class->trace->collection) { + if (file_stream->parent.events_discarded) { fflush(stdout); - fprintf(stderr, "[warning] Tracer discarded %" PRIu64 " events at end of stream between [", - file_stream->parent.events_discarded); - if (opt_clock_cycles) { - ctf_print_timestamp(stderr, - &file_stream->parent, - file_stream->parent.prev_cycles_timestamp); - fprintf(stderr, "] and ["); - ctf_print_timestamp(stderr, &file_stream->parent, - file_stream->parent.prev_cycles_timestamp_end); - } else { - ctf_print_timestamp(stderr, - &file_stream->parent, - file_stream->parent.prev_real_timestamp); - fprintf(stderr, "] and ["); - ctf_print_timestamp(stderr, &file_stream->parent, - file_stream->parent.prev_real_timestamp_end); - } - fprintf(stderr, "]. You should consider recording a new trace with larger buffers or with fewer events enabled.\n"); - fflush(stderr); + ctf_print_discarded(stderr, &file_stream->parent); + file_stream->parent.events_discarded = 0; } - file_stream->parent.events_discarded = 0; } pos->offset = EOF; return; @@ -1554,6 +1576,9 @@ int ctf_open_file_stream_read(struct ctf_trace *td, const char *path, int flags, file_stream = g_new0(struct ctf_file_stream, 1); file_stream->pos.last_offset = LAST_OFFSET_POISON; + strncpy(file_stream->parent.path, path, PATH_MAX); + file_stream->parent.path[PATH_MAX - 1] = '\0'; + if (packet_seek) { file_stream->pos.packet_seek = packet_seek; } else { diff --git a/include/babeltrace/ctf-ir/metadata.h b/include/babeltrace/ctf-ir/metadata.h index bc000151..91df0362 100644 --- a/include/babeltrace/ctf-ir/metadata.h +++ b/include/babeltrace/ctf-ir/metadata.h @@ -66,6 +66,7 @@ struct ctf_stream_definition { uint64_t prev_real_timestamp_end; /* End-of-last-packet timestamp in ns */ uint64_t prev_cycles_timestamp; /* Start-of-last-packet timestamp in cycles */ uint64_t prev_cycles_timestamp_end; /* End-of-last-packet timestamp in cycles */ + char path[PATH_MAX]; /* Path to stream. '\0' for mmap traces */ }; struct ctf_event_definition { diff --git a/include/babeltrace/ctf/events-internal.h b/include/babeltrace/ctf/events-internal.h index 0356906f..c7c28a1e 100644 --- a/include/babeltrace/ctf/events-internal.h +++ b/include/babeltrace/ctf/events-internal.h @@ -79,4 +79,6 @@ struct bt_ctf_iter { uint64_t events_lost; }; +void ctf_print_discarded(FILE *fp, struct ctf_stream_definition *stream); + #endif /*_BABELTRACE_CTF_EVENTS_INTERNAL_H */ -- 2.34.1