X-Git-Url: http://git.onelab.eu/?a=blobdiff_plain;f=lib%2Fcoverage.c;h=23e29973d4e825e2efd664c20456eaa386876998;hb=015ac88281952a1b43ad46e9e6300db1c6e3647b;hp=ff20f5e9c09ed159775690370f2cdc2de8e42b7a;hpb=275a506cbe10db1e673fa1182582a507ba69418e;p=sliver-openvswitch.git diff --git a/lib/coverage.c b/lib/coverage.c index ff20f5e9c..23e29973d 100644 --- a/lib/coverage.c +++ b/lib/coverage.c @@ -1,5 +1,5 @@ /* - * Copyright (c) 2009, 2010, 2011, 2012 Nicira Networks. + * Copyright (c) 2009, 2010, 2011, 2012, 2013 Nicira, Inc. * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. @@ -20,6 +20,7 @@ #include #include "dynamic-string.h" #include "hash.h" +#include "svec.h" #include "timeval.h" #include "unixctl.h" #include "util.h" @@ -34,10 +35,24 @@ extern struct coverage_counter *__stop_coverage[]; #define coverage_counters __start_coverage #define n_coverage_counters (__stop_coverage - __start_coverage) #else /* !USE_LINKER_SECTIONS */ -#define COVERAGE_COUNTER(NAME) COVERAGE_DEFINE__(NAME); +#define COVERAGE_COUNTER(COUNTER) \ + DECLARE_EXTERN_PER_THREAD_DATA(unsigned int, \ + counter_##COUNTER); \ + DEFINE_EXTERN_PER_THREAD_DATA(counter_##COUNTER, 0); \ + static unsigned int COUNTER##_count(void) \ + { \ + unsigned int *countp = counter_##COUNTER##_get(); \ + unsigned int count = *countp; \ + *countp = 0; \ + return count; \ + } \ + extern struct coverage_counter counter_##COUNTER; \ + struct coverage_counter counter_##COUNTER \ + = { #COUNTER, COUNTER##_count, 0 }; #include "coverage.def" #undef COVERAGE_COUNTER +extern struct coverage_counter *coverage_counters[]; struct coverage_counter *coverage_counters[] = { #define COVERAGE_COUNTER(NAME) &counter_##NAME, #include "coverage.def" @@ -46,25 +61,34 @@ struct coverage_counter *coverage_counters[] = { #define n_coverage_counters ARRAY_SIZE(coverage_counters) #endif /* !USE_LINKER_SECTIONS */ -static unsigned int epoch; +static struct ovs_mutex coverage_mutex = OVS_MUTEX_INITIALIZER; + +static void coverage_read(struct svec *); static void -coverage_unixctl_log(struct unixctl_conn *conn, int argc OVS_UNUSED, +coverage_unixctl_show(struct unixctl_conn *conn, int argc OVS_UNUSED, const char *argv[] OVS_UNUSED, void *aux OVS_UNUSED) { - coverage_log(VLL_WARN, false); - unixctl_command_reply(conn, NULL); + struct svec lines; + char *reply; + + svec_init(&lines); + coverage_read(&lines); + reply = svec_join(&lines, "\n", "\n"); + unixctl_command_reply(conn, reply); + free(reply); + svec_destroy(&lines); } void coverage_init(void) { - unixctl_command_register("coverage/log", "", 0, 0, - coverage_unixctl_log, NULL); + unixctl_command_register("coverage/show", "", 0, 0, + coverage_unixctl_show, NULL); } -/* Sorts coverage counters in descending order by count, within equal counts - * alphabetically by name. */ +/* Sorts coverage counters in descending order by total, within equal + * totals alphabetically by name. */ static int compare_coverage_counters(const void *a_, const void *b_) { @@ -72,8 +96,8 @@ compare_coverage_counters(const void *a_, const void *b_) const struct coverage_counter *const *bp = b_; const struct coverage_counter *a = *ap; const struct coverage_counter *b = *bp; - if (a->count != b->count) { - return a->count < b->count ? 1 : -1; + if (a->total != b->total) { + return a->total < b->total ? 1 : -1; } else { return strcmp(a->name, b->name); } @@ -86,11 +110,13 @@ coverage_hash(void) uint32_t hash = 0; int n_groups, i; - /* Sort coverage counters into groups with equal counts. */ + /* Sort coverage counters into groups with equal totals. */ c = xmalloc(n_coverage_counters * sizeof *c); + ovs_mutex_lock(&coverage_mutex); for (i = 0; i < n_coverage_counters; i++) { c[i] = coverage_counters[i]; } + ovs_mutex_unlock(&coverage_mutex); qsort(c, n_coverage_counters, sizeof *c, compare_coverage_counters); /* Hash the names in each group along with the rank. */ @@ -98,13 +124,13 @@ coverage_hash(void) for (i = 0; i < n_coverage_counters; ) { int j; - if (!c[i]->count) { + if (!c[i]->total) { break; } n_groups++; hash = hash_int(i, hash); for (j = i; j < n_coverage_counters; j++) { - if (c[j]->count != c[i]->count) { + if (c[j]->total != c[i]->total) { break; } hash = hash_string(c[j]->name, hash); @@ -144,72 +170,82 @@ coverage_hit(uint32_t hash) } } -static void -coverage_log_counter(enum vlog_level level, const struct coverage_counter *c) +/* Logs the coverage counters, unless a similar set of events has already been + * logged. + * + * This function logs at log level VLL_INFO. Use care before adjusting this + * level, because depending on its configuration, syslogd can write changes + * synchronously, which can cause the coverage messages to take several seconds + * to write. */ +void +coverage_log(void) { - VLOG(level, "%-24s %5u / %9llu", c->name, c->count, c->count + c->total); + static struct vlog_rate_limit rl = VLOG_RATE_LIMIT_INIT(1, 3); + + if (!VLOG_DROP_INFO(&rl)) { + uint32_t hash = coverage_hash(); + if (coverage_hit(hash)) { + VLOG_INFO("Skipping details of duplicate event coverage for " + "hash=%08"PRIx32, hash); + } else { + struct svec lines; + const char *line; + size_t i; + + svec_init(&lines); + coverage_read(&lines); + SVEC_FOR_EACH (i, line, &lines) { + VLOG_INFO("%s", line); + } + svec_destroy(&lines); + } + } } -/* Logs the coverage counters at the given vlog 'level'. If - * 'suppress_dups' is true, then duplicate events are not displayed. - * Care should be taken in the value used for 'level'. Depending on the - * configuration, syslog can write changes synchronously, which can - * cause the coverage messages to take several seconds to write. */ -void -coverage_log(enum vlog_level level, bool suppress_dups) +/* Adds coverage counter information to 'lines'. */ +static void +coverage_read(struct svec *lines) { - static struct vlog_rate_limit rl = VLOG_RATE_LIMIT_INIT(1, 3); + unsigned long long int *totals; size_t n_never_hit; uint32_t hash; size_t i; - if (suppress_dups - ? !vlog_is_enabled(THIS_MODULE, level) - : vlog_should_drop(THIS_MODULE, level, &rl)) { - return; - } - hash = coverage_hash(); - if (suppress_dups) { - if (coverage_hit(hash)) { - VLOG(level, "Skipping details of duplicate event coverage for " - "hash=%08"PRIx32" in epoch %u", hash, epoch); - return; - } - } n_never_hit = 0; - VLOG(level, "Event coverage (epoch %u/entire run), hash=%08"PRIx32":", - epoch, hash); + svec_add_nocopy(lines, + xasprintf("Event coverage, hash=%08"PRIx32":", hash)); + + totals = xmalloc(n_coverage_counters * sizeof *totals); + ovs_mutex_lock(&coverage_mutex); for (i = 0; i < n_coverage_counters; i++) { - struct coverage_counter *c = coverage_counters[i]; - if (c->count) { - coverage_log_counter(level, c); - } + totals[i] = coverage_counters[i]->total; } + ovs_mutex_unlock(&coverage_mutex); + for (i = 0; i < n_coverage_counters; i++) { - struct coverage_counter *c = coverage_counters[i]; - if (!c->count) { - if (c->total) { - coverage_log_counter(level, c); - } else { - n_never_hit++; - } + if (totals[i]) { + svec_add_nocopy(lines, xasprintf("%-24s %9llu", + coverage_counters[i]->name, + totals[i])); + } else { + n_never_hit++; } } - VLOG(level, "%zu events never hit", n_never_hit); + svec_add_nocopy(lines, xasprintf("%zu events never hit", n_never_hit)); + free(totals); } -/* Advances to the next epoch of coverage, resetting all the counters to 0. */ void coverage_clear(void) { size_t i; - epoch++; + ovs_mutex_lock(&coverage_mutex); for (i = 0; i < n_coverage_counters; i++) { struct coverage_counter *c = coverage_counters[i]; - c->total += c->count; - c->count = 0; + c->total += c->count(); } + ovs_mutex_unlock(&coverage_mutex); }