/*
- * Copyright (c) 2009, 2010, 2011, 2012, 2013 Nicira, Inc.
+ * Copyright (c) 2009, 2010, 2011, 2012, 2013, 2014 Nicira, Inc.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
#include "timeval.h"
#include "unixctl.h"
#include "util.h"
-#include "vlog.h"
+#include "openvswitch/vlog.h"
VLOG_DEFINE_THIS_MODULE(coverage);
/* The coverage counters. */
-#if USE_LINKER_SECTIONS
-extern struct coverage_counter *__start_coverage[];
-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(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"
-#undef COVERAGE_COUNTER
-};
-#define n_coverage_counters ARRAY_SIZE(coverage_counters)
-#endif /* !USE_LINKER_SECTIONS */
+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 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_show(struct unixctl_conn *conn, int argc OVS_UNUSED,
const char *argv[] OVS_UNUSED, void *aux OVS_UNUSED)
}
}
- svec_add_nocopy(lines, xasprintf("%zu events never hit", n_never_hit));
+ 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.
+ *
+ * Uses 'ovs_mutex_trylock()' if 'trylock' is true. This is to prevent
+ * multiple performance-critical threads contending over the 'coverage_mutex'.
+ *
+ * */
+static void
+coverage_clear__(bool trylock)
+{
+ 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;
+
+ if (trylock) {
+ /* Returns if cannot acquire lock. */
+ if (ovs_mutex_trylock(&coverage_mutex)) {
+ return;
+ }
+ } else {
+ 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;
+ }
+}
+
void
coverage_clear(void)
{
- size_t i;
+ coverage_clear__(false);
+}
- 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);
+void
+coverage_try_clear(void)
+{
+ coverage_clear__(true);
}
/* Runs approximately every COVERAGE_RUN_INTERVAL amount of time to update the
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;
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
/* 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;
+ unsigned int m_idx = idx % MIN_AVG_LEN;
+ unsigned int h_idx = idx / MIN_AVG_LEN;
c[i]->min[m_idx] = portion + (j == (slots - 1)
? count % slots : 0);
/* 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;
}
projects / cascardo / ovs.git / blobdiff