diff options
Diffstat (limited to 'src/spdk/app/trace')
| -rw-r--r-- | src/spdk/app/trace/.gitignore | 1 | ||||
| -rw-r--r-- | src/spdk/app/trace/Makefile | 51 | ||||
| -rw-r--r-- | src/spdk/app/trace/trace.cpp | 418 |
3 files changed, 470 insertions, 0 deletions
diff --git a/src/spdk/app/trace/.gitignore b/src/spdk/app/trace/.gitignore new file mode 100644 index 00000000..bbb611b8 --- /dev/null +++ b/src/spdk/app/trace/.gitignore @@ -0,0 +1 @@ +spdk_trace diff --git a/src/spdk/app/trace/Makefile b/src/spdk/app/trace/Makefile new file mode 100644 index 00000000..3d720d13 --- /dev/null +++ b/src/spdk/app/trace/Makefile @@ -0,0 +1,51 @@ +# +# BSD LICENSE +# +# Copyright (c) Intel Corporation. +# All rights reserved. +# +# Redistribution and use in source and binary forms, with or without +# modification, are permitted provided that the following conditions +# are met: +# +# * Redistributions of source code must retain the above copyright +# notice, this list of conditions and the following disclaimer. +# * Redistributions in binary form must reproduce the above copyright +# notice, this list of conditions and the following disclaimer in +# the documentation and/or other materials provided with the +# distribution. +# * Neither the name of Intel Corporation nor the names of its +# contributors may be used to endorse or promote products derived +# from this software without specific prior written permission. +# +# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS +# "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT +# LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR +# A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT +# OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, +# SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT +# LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, +# DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY +# THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +# (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE +# OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. +# + +SPDK_ROOT_DIR := $(abspath $(CURDIR)/../..) +include $(SPDK_ROOT_DIR)/mk/spdk.common.mk +include $(SPDK_ROOT_DIR)/mk/spdk.app.mk + +CXX_SRCS := trace.cpp + +APP = spdk_trace + +all: $(APP) + @: + +$(APP): $(OBJS) $(SPDK_LIBS) + $(LINK_CXX) + +clean: + $(CLEAN_C) $(APP) + +include $(SPDK_ROOT_DIR)/mk/spdk.deps.mk diff --git a/src/spdk/app/trace/trace.cpp b/src/spdk/app/trace/trace.cpp new file mode 100644 index 00000000..4c42c5ec --- /dev/null +++ b/src/spdk/app/trace/trace.cpp @@ -0,0 +1,418 @@ +/*- + * BSD LICENSE + * + * Copyright (c) Intel Corporation. + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * + * * Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * * Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in + * the documentation and/or other materials provided with the + * distribution. + * * Neither the name of Intel Corporation nor the names of its + * contributors may be used to endorse or promote products derived + * from this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS + * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT + * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR + * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT + * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, + * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT + * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, + * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY + * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE + * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +#include "spdk/stdinc.h" + +#include <map> + +extern "C" { +#include "spdk/trace.h" +#include "spdk/util.h" +} + +static struct spdk_trace_histories *g_histories; + +static void usage(void); + +struct entry_key { + entry_key(uint16_t _lcore, uint64_t _tsc) : lcore(_lcore), tsc(_tsc) {} + uint16_t lcore; + uint64_t tsc; +}; + +class compare_entry_key +{ +public: + bool operator()(const entry_key &first, const entry_key &second) const + { + if (first.tsc == second.tsc) { + return first.lcore < second.lcore; + } else { + return first.tsc < second.tsc; + } + } +}; + +typedef std::map<entry_key, spdk_trace_entry *, compare_entry_key> entry_map; + +entry_map g_entry_map; + +struct object_stats { + + std::map<uint64_t, uint64_t> start; + std::map<uint64_t, uint64_t> index; + std::map<uint64_t, uint64_t> size; + std::map<uint64_t, uint64_t> tpoint_id; + uint64_t counter; + + object_stats() : start(), index(), size(), tpoint_id(), counter(0) {} +}; + +struct object_stats g_stats[SPDK_TRACE_MAX_OBJECT]; + +static char *g_exe_name; +static int g_verbose = 1; + +static uint64_t g_tsc_rate; +static uint64_t g_first_tsc = 0x0; + +static float +get_us_from_tsc(uint64_t tsc, uint64_t tsc_rate) +{ + return ((float)tsc) * 1000 * 1000 / tsc_rate; +} + +static void +print_ptr(const char *arg_string, uint64_t arg) +{ + printf("%-7.7s0x%-14jx ", arg_string, arg); +} + +static void +print_uint64(const char *arg_string, uint64_t arg) +{ + /* + * Print arg as signed, since -1 is a common value especially + * for FLUSH WRITEBUF when writev() returns -1 due to full + * socket buffer. + */ + printf("%-7.7s%-16jd ", arg_string, arg); +} + +static void +print_size(uint32_t size) +{ + if (size > 0) { + printf("size: %6u ", size); + } else { + printf("%13s", " "); + } +} + +static void +print_object_id(uint8_t type, uint64_t id) +{ + printf("id: %c%-15jd ", g_histories->flags.object[type].id_prefix, id); +} + +static void +print_float(const char *arg_string, float arg) +{ + printf("%-7s%-16.3f ", arg_string, arg); +} + +static void +print_arg(bool arg_is_ptr, const char *arg_string, uint64_t arg) +{ + if (arg_string[0] == 0) { + printf("%24s", ""); + return; + } + + if (arg_is_ptr) { + print_ptr(arg_string, arg); + } else { + print_uint64(arg_string, arg); + } +} + +static void +print_event(struct spdk_trace_entry *e, uint64_t tsc_rate, + uint64_t tsc_offset, uint16_t lcore) +{ + struct spdk_trace_tpoint *d; + struct object_stats *stats; + float us; + + d = &g_histories->flags.tpoint[e->tpoint_id]; + stats = &g_stats[d->object_type]; + + if (d->new_object) { + stats->index[e->object_id] = stats->counter++; + stats->tpoint_id[e->object_id] = e->tpoint_id; + stats->start[e->object_id] = e->tsc; + stats->size[e->object_id] = e->size; + } + + us = get_us_from_tsc(e->tsc - tsc_offset, tsc_rate); + + printf("%2d: %10.3f (%9ju) ", lcore, us, e->tsc - tsc_offset); + if (g_histories->flags.owner[d->owner_type].id_prefix) { + printf("%c%02d ", g_histories->flags.owner[d->owner_type].id_prefix, e->poller_id); + } else { + printf("%4s", " "); + } + + printf("%-*s ", (int)sizeof(d->name), d->name); + print_size(e->size); + + print_arg(d->arg1_is_ptr, d->arg1_name, e->arg1); + if (d->new_object) { + print_object_id(d->object_type, stats->index[e->object_id]); + } else if (d->object_type != OBJECT_NONE) { + if (stats->start.find(e->object_id) != stats->start.end()) { + struct spdk_trace_tpoint *start_description; + + us = get_us_from_tsc(e->tsc - stats->start[e->object_id], + tsc_rate); + print_object_id(d->object_type, stats->index[e->object_id]); + print_float("time:", us); + start_description = &g_histories->flags.tpoint[stats->tpoint_id[e->object_id]]; + if (start_description->short_name[0] != 0) { + printf(" (%.4s)", start_description->short_name); + } + } else { + printf("id: N/A"); + } + } else if (e->object_id != 0) { + print_arg(true, "object: ", e->object_id); + } + printf("\n"); +} + +static void +process_event(struct spdk_trace_entry *e, uint64_t tsc_rate, + uint64_t tsc_offset, uint16_t lcore) +{ + if (g_verbose) { + print_event(e, tsc_rate, tsc_offset, lcore); + } +} + +static int +populate_events(struct spdk_trace_history *history) +{ + int i, num_entries, num_entries_filled; + struct spdk_trace_entry *e; + int first, last, lcore; + + lcore = history->lcore; + + num_entries = SPDK_COUNTOF(history->entries); + + e = history->entries; + + num_entries_filled = num_entries; + while (e[num_entries_filled - 1].tsc == 0) { + num_entries_filled--; + } + + if (num_entries == num_entries_filled) { + first = last = 0; + for (i = 1; i < num_entries; i++) { + if (e[i].tsc < e[first].tsc) { + first = i; + } + if (e[i].tsc > e[last].tsc) { + last = i; + } + } + } else { + first = 0; + last = num_entries_filled - 1; + } + + /* + * We keep track of the highest first TSC out of all reactors. + * We will ignore any events that occured before this TSC on any + * other reactors. This will ensure we only print data for the + * subset of time where we have data across all reactors. + */ + if (e[first].tsc > g_first_tsc) { + g_first_tsc = e[first].tsc; + } + + i = first; + while (1) { + g_entry_map[entry_key(lcore, e[i].tsc)] = &e[i]; + if (i == last) { + break; + } + i++; + if (i == num_entries_filled) { + i = 0; + } + } + + return (0); +} + +static void usage(void) +{ + fprintf(stderr, "usage:\n"); + fprintf(stderr, " %s <option> <lcore#>\n", g_exe_name); + fprintf(stderr, " option = '-q' to disable verbose mode\n"); + fprintf(stderr, " '-c' to display single lcore history\n"); + fprintf(stderr, " '-s' to specify spdk_trace shm name for a\n"); + fprintf(stderr, " currently running process\n"); + fprintf(stderr, " '-i' to specify the shared memory ID\n"); + fprintf(stderr, " '-p' to specify the trace PID\n"); + fprintf(stderr, " (If -s is specified, then one of\n"); + fprintf(stderr, " -i or -p must be specified)\n"); + fprintf(stderr, " '-f' to specify a tracepoint file name\n"); + fprintf(stderr, " (-s and -f are mutually exclusive)\n"); +} + +int main(int argc, char **argv) +{ + void *history_ptr; + struct spdk_trace_history *history_entries, *history; + int fd, i; + int lcore = SPDK_TRACE_MAX_LCORE; + uint64_t tsc_offset; + const char *app_name = NULL; + const char *file_name = NULL; + int op; + char shm_name[64]; + int shm_id = -1, shm_pid = -1; + + g_exe_name = argv[0]; + while ((op = getopt(argc, argv, "c:f:i:p:qs:")) != -1) { + switch (op) { + case 'c': + lcore = atoi(optarg); + if (lcore > SPDK_TRACE_MAX_LCORE) { + fprintf(stderr, "Selected lcore: %d " + "exceeds maximum %d\n", lcore, + SPDK_TRACE_MAX_LCORE); + exit(1); + } + break; + case 'i': + shm_id = atoi(optarg); + break; + case 'p': + shm_pid = atoi(optarg); + break; + case 'q': + g_verbose = 0; + break; + case 's': + app_name = optarg; + break; + case 'f': + file_name = optarg; + break; + default: + usage(); + exit(1); + } + } + + if (file_name != NULL && app_name != NULL) { + fprintf(stderr, "-f and -s are mutually exclusive\n"); + usage(); + exit(1); + } + + if (file_name == NULL && app_name == NULL) { + fprintf(stderr, "One of -f and -s must be specified\n"); + usage(); + exit(1); + } + + if (shm_id >= 0) { + snprintf(shm_name, sizeof(shm_name), "/%s_trace.%d", app_name, shm_id); + } else { + snprintf(shm_name, sizeof(shm_name), "/%s_trace.pid%d", app_name, shm_pid); + } + + if (file_name) { + fd = open(file_name, O_RDONLY); + } else { + fd = shm_open(shm_name, O_RDONLY, 0600); + } + if (fd < 0) { + fprintf(stderr, "Could not open %s.\n", file_name ? file_name : shm_name); + usage(); + exit(-1); + } + + history_ptr = mmap(NULL, sizeof(*g_histories), PROT_READ, MAP_SHARED, fd, 0); + if (history_ptr == MAP_FAILED) { + fprintf(stderr, "Could not mmap shm %s.\n", shm_name); + usage(); + exit(-1); + } + + g_histories = (struct spdk_trace_histories *)history_ptr; + + g_tsc_rate = g_histories->flags.tsc_rate; + if (g_tsc_rate == 0) { + fprintf(stderr, "Invalid tsc_rate %ju\n", g_tsc_rate); + usage(); + exit(-1); + } + + if (g_verbose) { + printf("TSC Rate: %ju\n", g_tsc_rate); + } + + history_entries = (struct spdk_trace_history *)malloc(sizeof(g_histories->per_lcore_history)); + if (history_entries == NULL) { + goto cleanup; + } + memcpy(history_entries, g_histories->per_lcore_history, + sizeof(g_histories->per_lcore_history)); + + if (lcore == SPDK_TRACE_MAX_LCORE) { + for (i = 0; i < SPDK_TRACE_MAX_LCORE; i++) { + history = &history_entries[i]; + if (history->entries[0].tsc == 0) { + continue; + } + populate_events(history); + } + } else { + history = &history_entries[lcore]; + if (history->entries[0].tsc != 0) { + populate_events(history); + } + } + + tsc_offset = g_first_tsc; + for (entry_map::iterator it = g_entry_map.begin(); it != g_entry_map.end(); it++) { + if (it->first.tsc < g_first_tsc) { + continue; + } + process_event(it->second, g_tsc_rate, tsc_offset, it->first.lcore); + } + + free(history_entries); + +cleanup: + munmap(history_ptr, sizeof(*g_histories)); + close(fd); + + return (0); +} |