X-Git-Url: http://git.onelab.eu/?a=blobdiff_plain;f=lib%2Fcoverage.c;h=cc17e342a434fc6f7909016556a759c411c7dba1;hb=HEAD;hp=6f805e9eacd44b2c9be0fe825708d5629e55bcc7;hpb=67ca9e6d90808f22332cf475ad01e01bf5d46c4f;p=sliver-openvswitch.git diff --git a/lib/coverage.c b/lib/coverage.c index 6f805e9ea..cc17e342a 100644 --- a/lib/coverage.c +++ b/lib/coverage.c @@ -1,5 +1,5 @@ /* - * Copyright (c) 2009 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. @@ -18,32 +18,69 @@ #include "coverage.h" #include #include -#include "coverage-counters.h" #include "dynamic-string.h" #include "hash.h" +#include "svec.h" +#include "timeval.h" #include "unixctl.h" #include "util.h" - -#define THIS_MODULE VLM_coverage #include "vlog.h" -static unsigned int epoch; +VLOG_DEFINE_THIS_MODULE(coverage); + +/* The coverage counters. */ +static struct coverage_counter **coverage_counters = NULL; +static size_t n_coverage_counters = 0; +static size_t allocated_coverage_counters = 0; + +static struct ovs_mutex coverage_mutex = OVS_MUTEX_INITIALIZER; + +DEFINE_STATIC_PER_THREAD_DATA(long long int, coverage_clear_time, LLONG_MIN); +static long long int coverage_run_time = LLONG_MIN; + +/* Index counter used to compute the moving average array's index. */ +static unsigned int idx_count = 0; + +static void coverage_read(struct svec *); +static unsigned int coverage_array_sum(const unsigned int *arr, + const unsigned int len); + +/* Registers a coverage counter with the coverage core */ +void +coverage_counter_register(struct coverage_counter* counter) +{ + if (n_coverage_counters >= allocated_coverage_counters) { + coverage_counters = x2nrealloc(coverage_counters, + &allocated_coverage_counters, + sizeof(struct coverage_counter*)); + } + coverage_counters[n_coverage_counters++] = counter; +} static void -coverage_unixctl_log(struct unixctl_conn *conn, const char *args 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, 200, 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", coverage_unixctl_log); + 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_) { @@ -51,8 +88,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); } @@ -65,25 +102,27 @@ coverage_hash(void) uint32_t hash = 0; int n_groups, i; - /* Sort coverage counters into groups with equal counts. */ - c = xmalloc(coverage_n_counters * sizeof *c); - for (i = 0; i < coverage_n_counters; i++) { + /* 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]; } - qsort(c, coverage_n_counters, sizeof *c, compare_coverage_counters); + 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. */ n_groups = 0; - for (i = 0; i < coverage_n_counters; ) { + 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 < coverage_n_counters; j++) { - if (c[j]->count != c[i]->count) { + for (j = i; j < n_coverage_counters; j++) { + if (c[j]->total != c[i]->total) { break; } hash = hash_string(c[j]->name, hash); @@ -103,10 +142,18 @@ coverage_hit(uint32_t hash) static uint32_t hit[HIT_BITS / BITS_PER_WORD]; BUILD_ASSERT_DECL(IS_POW2(HIT_BITS)); + static long long int next_clear = LLONG_MIN; + unsigned int bit_index = hash & (HIT_BITS - 1); unsigned int word_index = bit_index / BITS_PER_WORD; unsigned int word_mask = 1u << (bit_index % BITS_PER_WORD); + /* Expire coverage hash suppression once a day. */ + if (time_msec() >= next_clear) { + memset(hit, 0, sizeof hit); + next_clear = time_msec() + 60 * 60 * 24 * 1000LL; + } + if (hit[word_index] & word_mask) { return true; } else { @@ -115,66 +162,194 @@ 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. */ -void -coverage_log(enum vlog_level level, bool suppress_dups) +/* Adds coverage counter information to 'lines'. */ +static void +coverage_read(struct svec *lines) { + struct coverage_counter **c = coverage_counters; + unsigned long long int *totals; size_t n_never_hit; uint32_t hash; size_t i; - if (!vlog_is_enabled(THIS_MODULE, level)) { - return; + hash = coverage_hash(); + + n_never_hit = 0; + svec_add_nocopy(lines, + xasprintf("Event coverage, avg rate over last: %d " + "seconds, last minute, last hour, " + "hash=%08"PRIx32":", + COVERAGE_RUN_INTERVAL/1000, hash)); + + totals = xmalloc(n_coverage_counters * sizeof *totals); + ovs_mutex_lock(&coverage_mutex); + for (i = 0; i < n_coverage_counters; i++) { + totals[i] = c[i]->total; } + ovs_mutex_unlock(&coverage_mutex); - if (suppress_dups) { - hash = coverage_hash(); - if (coverage_hit(hash)) { - VLOG(level, "Skipping details of duplicate event coverage for " - "hash=%08"PRIx32" in epoch %u", hash, epoch); - return; + for (i = 0; i < n_coverage_counters; i++) { + if (totals[i]) { + /* Shows the averaged per-second rates for the last + * COVERAGE_RUN_INTERVAL interval, the last minute and + * the last hour. */ + svec_add_nocopy(lines, + xasprintf("%-24s %5.1f/sec %9.3f/sec " + "%13.4f/sec total: %llu", + c[i]->name, + (c[i]->min[(idx_count - 1) % MIN_AVG_LEN] + * 1000.0 / COVERAGE_RUN_INTERVAL), + coverage_array_sum(c[i]->min, MIN_AVG_LEN) / 60.0, + coverage_array_sum(c[i]->hr, HR_AVG_LEN) / 3600.0, + totals[i])); + } else { + n_never_hit++; } } - n_never_hit = 0; - VLOG(level, "Event coverage (epoch %u/entire run), hash=%08"PRIx32":", - epoch, hash); - for (i = 0; i < coverage_n_counters; i++) { - struct coverage_counter *c = coverage_counters[i]; - if (c->count) { - coverage_log_counter(level, c); + svec_add_nocopy(lines, xasprintf("%"PRIuSIZE" events never hit", n_never_hit)); + free(totals); +} + +/* Runs approximately every COVERAGE_CLEAR_INTERVAL amount of time to + * synchronize per-thread counters with global counters. Every thread maintains + * a separate timer to ensure all counters are periodically aggregated. */ +void +coverage_clear(void) +{ + long long int now, *thread_time; + + now = time_msec(); + thread_time = coverage_clear_time_get(); + + /* Initialize the coverage_clear_time. */ + if (*thread_time == LLONG_MIN) { + *thread_time = now + COVERAGE_CLEAR_INTERVAL; + } + + if (now >= *thread_time) { + size_t i; + + ovs_mutex_lock(&coverage_mutex); + for (i = 0; i < n_coverage_counters; i++) { + struct coverage_counter *c = coverage_counters[i]; + c->total += c->count(); } + ovs_mutex_unlock(&coverage_mutex); + *thread_time = now + COVERAGE_CLEAR_INTERVAL; } - for (i = 0; i < coverage_n_counters; i++) { - struct coverage_counter *c = coverage_counters[i]; - if (!c->count) { - if (c->total) { - coverage_log_counter(level, c); - } else { - n_never_hit++; +} + +/* Runs approximately every COVERAGE_RUN_INTERVAL amount of time to update the + * coverage counters' 'min' and 'hr' array. 'min' array is for cumulating + * per second counts into per minute count. 'hr' array is for cumulating per + * minute counts into per hour count. Every thread may call this function. */ +void +coverage_run(void) +{ + /* Defines the moving average array index variables. */ + static unsigned int min_idx, hr_idx; + struct coverage_counter **c = coverage_counters; + long long int now; + + ovs_mutex_lock(&coverage_mutex); + now = time_msec(); + /* Initialize the coverage_run_time. */ + if (coverage_run_time == LLONG_MIN) { + coverage_run_time = now + COVERAGE_RUN_INTERVAL; + } + + if (now >= coverage_run_time) { + size_t i, j; + /* Computes the number of COVERAGE_RUN_INTERVAL slots, since + * it is possible that the actual run interval is multiple of + * COVERAGE_RUN_INTERVAL. */ + int slots = (now - coverage_run_time) / COVERAGE_RUN_INTERVAL + 1; + + for (i = 0; i < n_coverage_counters; i++) { + unsigned int count, portion; + unsigned int m_idx = min_idx; + unsigned int h_idx = hr_idx; + unsigned int idx = idx_count; + + /* Computes the differences between the current total and the one + * recorded in last invocation of coverage_run(). */ + count = c[i]->total - c[i]->last_total; + c[i]->last_total = c[i]->total; + /* The count over the time interval is evenly distributed + * among slots by calculating the portion. */ + portion = count / slots; + + for (j = 0; j < slots; j++) { + /* Updates the index variables. */ + /* The m_idx is increased from 0 to MIN_AVG_LEN - 1. Every + * time the m_idx finishes a cycle (a cycle is one minute), + * the h_idx is incremented by 1. */ + m_idx = idx % MIN_AVG_LEN; + h_idx = idx / MIN_AVG_LEN; + + c[i]->min[m_idx] = portion + (j == (slots - 1) + ? count % slots : 0); + c[i]->hr[h_idx] = m_idx == 0 + ? c[i]->min[m_idx] + : (c[i]->hr[h_idx] + c[i]->min[m_idx]); + /* This is to guarantee that h_idx ranges from 0 to 59. */ + idx = (idx + 1) % (MIN_AVG_LEN * HR_AVG_LEN); } } + + /* Updates the global index variables. */ + idx_count = (idx_count + slots) % (MIN_AVG_LEN * HR_AVG_LEN); + min_idx = idx_count % MIN_AVG_LEN; + hr_idx = idx_count / MIN_AVG_LEN; + /* Updates the run time. */ + coverage_run_time = now + COVERAGE_RUN_INTERVAL; } - VLOG(level, "%zu events never hit", n_never_hit); + ovs_mutex_unlock(&coverage_mutex); } -/* Advances to the next epoch of coverage, resetting all the counters to 0. */ -void -coverage_clear(void) +static unsigned int +coverage_array_sum(const unsigned int *arr, const unsigned int len) { + unsigned int sum = 0; size_t i; - epoch++; - for (i = 0; i < coverage_n_counters; i++) { - struct coverage_counter *c = coverage_counters[i]; - c->total += c->count; - c->count = 0; + ovs_mutex_lock(&coverage_mutex); + for (i = 0; i < len; i++) { + sum += arr[i]; } + ovs_mutex_unlock(&coverage_mutex); + return sum; }