2 * Copyright (c) 2009 Nicira Networks.
4 * Licensed under the Apache License, Version 2.0 (the "License");
5 * you may not use this file except in compliance with the License.
6 * You may obtain a copy of the License at:
8 * http://www.apache.org/licenses/LICENSE-2.0
10 * Unless required by applicable law or agreed to in writing, software
11 * distributed under the License is distributed on an "AS IS" BASIS,
12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 * See the License for the specific language governing permissions and
14 * limitations under the License.
21 #include "coverage-counters.h"
22 #include "dynamic-string.h"
27 #define THIS_MODULE VLM_coverage
30 static unsigned int epoch;
33 coverage_unixctl_log(struct unixctl_conn *conn, const char *args UNUSED)
35 coverage_log(VLL_WARN, false);
36 unixctl_command_reply(conn, 200, NULL);
40 coverage_unixctl_clear(struct unixctl_conn *conn, const char *args UNUSED)
43 unixctl_command_reply(conn, 200, NULL);
49 unixctl_command_register("coverage/log", coverage_unixctl_log);
50 unixctl_command_register("coverage/clear", coverage_unixctl_clear);
53 /* Sorts coverage counters in descending order by count, within equal counts
54 * alphabetically by name. */
56 compare_coverage_counters(const void *a_, const void *b_)
58 const struct coverage_counter *const *ap = a_;
59 const struct coverage_counter *const *bp = b_;
60 const struct coverage_counter *a = *ap;
61 const struct coverage_counter *b = *bp;
62 if (a->count != b->count) {
63 return a->count < b->count ? 1 : -1;
65 return strcmp(a->name, b->name);
72 struct coverage_counter **c;
76 /* Sort coverage counters into groups with equal counts. */
77 c = xmalloc(coverage_n_counters * sizeof *c);
78 for (i = 0; i < coverage_n_counters; i++) {
79 c[i] = coverage_counters[i];
81 qsort(c, coverage_n_counters, sizeof *c, compare_coverage_counters);
83 /* Hash the names in each group along with the rank. */
85 for (i = 0; i < coverage_n_counters; ) {
92 hash = hash_int(i, hash);
93 for (j = i; j < coverage_n_counters; j++) {
94 if (c[j]->count != c[i]->count) {
97 hash = hash_string(c[j]->name, hash);
104 return hash_int(n_groups, hash);
108 coverage_hit(uint32_t hash)
110 enum { HIT_BITS = 1024, BITS_PER_WORD = 32 };
111 static uint32_t hit[HIT_BITS / BITS_PER_WORD];
112 BUILD_ASSERT_DECL(IS_POW2(HIT_BITS));
114 unsigned int bit_index = hash & (HIT_BITS - 1);
115 unsigned int word_index = bit_index / BITS_PER_WORD;
116 unsigned int word_mask = 1u << (bit_index % BITS_PER_WORD);
118 if (hit[word_index] & word_mask) {
121 hit[word_index] |= word_mask;
127 coverage_log_counter(enum vlog_level level, const struct coverage_counter *c)
129 VLOG(level, "%-24s %5u / %9llu", c->name, c->count, c->count + c->total);
132 /* Logs the coverage counters at the given vlog 'level'. If
133 * 'suppress_dups' is true, then duplicate events are not displayed. */
135 coverage_log(enum vlog_level level, bool suppress_dups)
141 if (!vlog_is_enabled(THIS_MODULE, level)) {
146 hash = coverage_hash();
147 if (coverage_hit(hash)) {
148 VLOG(level, "Skipping details of duplicate event coverage for "
149 "hash=%08"PRIx32" in epoch %u", hash, epoch);
155 VLOG(level, "Event coverage (epoch %u/entire run), hash=%08"PRIx32":",
157 for (i = 0; i < coverage_n_counters; i++) {
158 struct coverage_counter *c = coverage_counters[i];
160 coverage_log_counter(level, c);
163 for (i = 0; i < coverage_n_counters; i++) {
164 struct coverage_counter *c = coverage_counters[i];
167 coverage_log_counter(level, c);
173 VLOG(level, "%zu events never hit", n_never_hit);
176 /* Advances to the next epoch of coverage, resetting all the counters to 0. */
183 for (i = 0; i < coverage_n_counters; i++) {
184 struct coverage_counter *c = coverage_counters[i];
185 c->total += c->count;