lib/perf-counter.c

   1 /*
   2  * Copyright (c) 2015 Nicira, Inc.
   3  *
   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:
   7  *
   8  *     http://www.apache.org/licenses/LICENSE-2.0
   9  *
  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.
  15  */
  16
  17 /* This implementation only applies to the Linux platform.  */
  18
  19 #include <config.h>
  20 #if defined(__linux__) && defined(HAVE_LINUX_PERF_EVENT_H)
  21
  22 #include <stddef.h>
  23 #include <sys/types.h>
  24 #include <stdlib.h>
  25 #include <unistd.h>
  26 #include <sys/ioctl.h>
  27 #include <linux/perf_event.h>
  28 #include <asm/unistd.h>
  29 #include "dynamic-string.h"
  30 #include "perf-counter.h"
  31 #include "shash.h"
  32 #include "util.h"
  33
  34 static struct shash perf_counters = SHASH_INITIALIZER(&perf_counters);
  35 static int fd__ = 0;
  36
  37 uint64_t
  38 perf_counter_read(uint64_t *counter)
  39 {
  40     int size = sizeof *counter;
  41
  42     if (fd__ <= 0 || read(fd__, counter, size) < size) {
  43         *counter = 0;
  44     }
  45
  46     return *counter;
  47 }
  48
  49 static long
  50 perf_event_open(struct perf_event_attr *hw_event, pid_t pid,
  51                 int cpu, int group_fd, unsigned long flags)
  52 {
  53     int ret;
  54
  55     ret = syscall(__NR_perf_event_open, hw_event, pid, cpu,
  56                   group_fd, flags);
  57     return ret;
  58 }
  59
  60 /* Set up perf event counters to read user space instruction counters
  61  * only for this process, on all cpus.   */
  62 static void
  63 perf_event_setup(void)
  64 {
  65     struct perf_event_attr pe;
  66
  67     memset(&pe, 0, sizeof(struct perf_event_attr));
  68     pe.type = PERF_TYPE_HARDWARE;
  69     pe.size = sizeof(struct perf_event_attr);
  70     pe.config = PERF_COUNT_HW_INSTRUCTIONS;
  71     pe.disabled = 1;
  72     pe.exclude_kernel = 1;
  73     pe.exclude_hv = 1;
  74
  75     fd__ = perf_event_open(&pe, 0, -1, -1, 0);
  76     if (fd__ > 0) {
  77         ioctl(fd__, PERF_EVENT_IOC_RESET, 0);
  78         ioctl(fd__, PERF_EVENT_IOC_ENABLE, 0);
  79     }
  80 }
  81
  82 static void
  83 perf_counter_init(struct perf_counter *counter)
  84 {
  85     counter->once = true;
  86     shash_add_assert(&perf_counters, counter->name, counter);
  87 }
  88
  89 void
  90 perf_counter_accumulate(struct perf_counter *counter, uint64_t start_count)
  91 {
  92     uint64_t end_count;
  93
  94     if (!counter->once) {
  95         perf_counter_init(counter);
  96     }
  97
  98     counter->n_events++;
  99     perf_counter_read(&end_count);
 100     counter->total_count += end_count - start_count;
 101 }
 102
 103 static void
 104 perf_counter_to_ds(struct ds *ds, struct perf_counter *pfc)
 105 {
 106     double ratio;
 107
 108     if (pfc->n_events) {
 109         ratio = (double)pfc->total_count / (double)pfc->n_events;
 110     } else {
 111         ratio = 0.0;
 112     }
 113
 114     ds_put_format(ds, "%-40s%12"PRIu64"%12"PRIu64"%12.1f\n",
 115                   pfc->name, pfc->n_events, pfc->total_count, ratio);
 116 }
 117
 118 static void
 119 perf_counters_to_ds(struct ds *ds)
 120 {
 121     const char *err_str;
 122     const struct shash_node **sorted;
 123     int i;
 124
 125     err_str = NULL;
 126     if (fd__ == -1) {
 127         err_str = "performance counter is not supported on this platfrom";
 128     } else if (!shash_count(&perf_counters)) {
 129         err_str = "performance counter has never been hit";
 130     }
 131
 132     if (err_str) {
 133         ds_put_format(ds, "%s\n", err_str);
 134         return;
 135     }
 136
 137     /* Display counters in alphabetical order.  */
 138     sorted = shash_sort(&perf_counters);
 139     for (i = 0; i < shash_count(&perf_counters); i++) {
 140         perf_counter_to_ds(ds, sorted[i]->data);
 141     }
 142     free(sorted);
 143 }
 144
 145 /*
 146  * Caller is responsible for free memory.
 147  */
 148 char *
 149 perf_counters_to_string()
 150 {
 151     struct ds ds;
 152
 153     ds_init(&ds);
 154     perf_counters_to_ds(&ds);
 155     return ds_steal_cstr(&ds);
 156 }
 157
 158 void
 159 perf_counters_init(void)
 160 {
 161     shash_init(&perf_counters);
 162     perf_event_setup();
 163 }
 164
 165 void
 166 perf_counters_clear(void)
 167 {
 168     struct shash_node *node;
 169
 170     SHASH_FOR_EACH (node, &perf_counters) {
 171         struct perf_counter *perf = node->data;
 172
 173         perf->n_events = 0;
 174         perf->total_count = 0;
 175     }
 176 }
 177
 178 void
 179 perf_counters_destroy()
 180 {
 181     struct shash_node *node, *next;
 182
 183     if (fd__ != -1) {
 184         ioctl(fd__, PERF_EVENT_IOC_DISABLE, 0);
 185         close(fd__);
 186     }
 187
 188     SHASH_FOR_EACH_SAFE (node, next, &perf_counters) {
 189         shash_delete(&perf_counters, node);
 190     }
 191
 192     shash_destroy(&perf_counters);
 193 }
 194 #endif