2 * Copyright (c) 2009, 2010 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"
28 VLOG_DEFINE_THIS_MODULE(coverage
)
30 static unsigned int epoch
;
33 coverage_unixctl_log(struct unixctl_conn
*conn
, const char *args OVS_UNUSED
,
36 coverage_log(VLL_WARN
, false);
37 unixctl_command_reply(conn
, 200, NULL
);
43 unixctl_command_register("coverage/log", coverage_unixctl_log
, NULL
);
46 /* Sorts coverage counters in descending order by count, within equal counts
47 * alphabetically by name. */
49 compare_coverage_counters(const void *a_
, const void *b_
)
51 const struct coverage_counter
*const *ap
= a_
;
52 const struct coverage_counter
*const *bp
= b_
;
53 const struct coverage_counter
*a
= *ap
;
54 const struct coverage_counter
*b
= *bp
;
55 if (a
->count
!= b
->count
) {
56 return a
->count
< b
->count
? 1 : -1;
58 return strcmp(a
->name
, b
->name
);
65 struct coverage_counter
**c
;
69 /* Sort coverage counters into groups with equal counts. */
70 c
= xmalloc(coverage_n_counters
* sizeof *c
);
71 for (i
= 0; i
< coverage_n_counters
; i
++) {
72 c
[i
] = coverage_counters
[i
];
74 qsort(c
, coverage_n_counters
, sizeof *c
, compare_coverage_counters
);
76 /* Hash the names in each group along with the rank. */
78 for (i
= 0; i
< coverage_n_counters
; ) {
85 hash
= hash_int(i
, hash
);
86 for (j
= i
; j
< coverage_n_counters
; j
++) {
87 if (c
[j
]->count
!= c
[i
]->count
) {
90 hash
= hash_string(c
[j
]->name
, hash
);
97 return hash_int(n_groups
, hash
);
101 coverage_hit(uint32_t hash
)
103 enum { HIT_BITS
= 1024, BITS_PER_WORD
= 32 };
104 static uint32_t hit
[HIT_BITS
/ BITS_PER_WORD
];
105 BUILD_ASSERT_DECL(IS_POW2(HIT_BITS
));
107 unsigned int bit_index
= hash
& (HIT_BITS
- 1);
108 unsigned int word_index
= bit_index
/ BITS_PER_WORD
;
109 unsigned int word_mask
= 1u << (bit_index
% BITS_PER_WORD
);
111 if (hit
[word_index
] & word_mask
) {
114 hit
[word_index
] |= word_mask
;
120 coverage_log_counter(enum vlog_level level
, const struct coverage_counter
*c
)
122 VLOG(level
, "%-24s %5u / %9llu", c
->name
, c
->count
, c
->count
+ c
->total
);
125 /* Logs the coverage counters at the given vlog 'level'. If
126 * 'suppress_dups' is true, then duplicate events are not displayed.
127 * Care should be taken in the value used for 'level'. Depending on the
128 * configuration, syslog can write changes synchronously, which can
129 * cause the coverage messages to take several seconds to write. */
131 coverage_log(enum vlog_level level
, bool suppress_dups
)
137 if (!vlog_is_enabled(THIS_MODULE
, level
)) {
141 hash
= coverage_hash();
143 if (coverage_hit(hash
)) {
144 VLOG(level
, "Skipping details of duplicate event coverage for "
145 "hash=%08"PRIx32
" in epoch %u", hash
, epoch
);
151 VLOG(level
, "Event coverage (epoch %u/entire run), hash=%08"PRIx32
":",
153 for (i
= 0; i
< coverage_n_counters
; i
++) {
154 struct coverage_counter
*c
= coverage_counters
[i
];
156 coverage_log_counter(level
, c
);
159 for (i
= 0; i
< coverage_n_counters
; i
++) {
160 struct coverage_counter
*c
= coverage_counters
[i
];
163 coverage_log_counter(level
, c
);
169 VLOG(level
, "%zu events never hit", n_never_hit
);
172 /* Advances to the next epoch of coverage, resetting all the counters to 0. */
179 for (i
= 0; i
< coverage_n_counters
; i
++) {
180 struct coverage_counter
*c
= coverage_counters
[i
];
181 c
->total
+= c
->count
;