FD.io VPP  v19.04.4-rc0-5-ge88582fac
Vector Packet Processing
perfmon_periodic.c
Go to the documentation of this file.
1 /*
2  * perfmon_periodic.c - skeleton plug-in periodic function
3  *
4  * Copyright (c) <current-year> <your-organization>
5  * Licensed under the Apache License, Version 2.0 (the "License");
6  * you may not use this file except in compliance with the License.
7  * You may obtain a copy of the License at:
8  *
9  * http://www.apache.org/licenses/LICENSE-2.0
10  *
11  * Unless required by applicable law or agreed to in writing, software
12  * distributed under the License is distributed on an "AS IS" BASIS,
13  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
14  * See the License for the specific language governing permissions and
15  * limitations under the License.
16  */
17 
18 #include <vlib/vlib.h>
19 #include <vppinfra/error.h>
20 #include <perfmon/perfmon.h>
21 #include <asm/unistd.h>
22 #include <sys/ioctl.h>
23 
24 /* "not in glibc" */
25 static long
26 perf_event_open (struct perf_event_attr *hw_event, pid_t pid, int cpu,
27  int group_fd, unsigned long flags)
28 {
29  int ret;
30 
31  ret = syscall (__NR_perf_event_open, hw_event, pid, cpu, group_fd, flags);
32  return ret;
33 }
34 
35 static void
37 {
38  int i;
39  u64 *cc;
41  uword my_thread_index = vm->thread_index;
42 
43  *c0 = *c1 = 0;
44 
45  for (i = 0; i < pm->n_active; i++)
46  {
47  cc = (i == 0) ? c0 : c1;
48  if (pm->rdpmc_indices[i][my_thread_index] != ~0)
49  *cc = clib_rdpmc ((int) pm->rdpmc_indices[i][my_thread_index]);
50  else
51  {
52  u64 sw_value;
53  if (read (pm->pm_fds[i][my_thread_index], &sw_value,
54  sizeof (sw_value)) != sizeof (sw_value))
55  {
57  ("counter read failed, disable collection...");
59  return;
60  }
61  *cc = sw_value;
62  }
63  }
64 }
65 
66 static void
68 {
69  int i, j;
70  vlib_main_t *vm = pm->vlib_main;
71  vlib_main_t *stat_vm;
72  vlib_node_main_t *nm;
73  vlib_node_t *n;
74 
76 
77  for (j = 0; j < vec_len (vlib_mains); j++)
78  {
79  stat_vm = vlib_mains[j];
80  if (stat_vm == 0)
81  continue;
82 
83  nm = &stat_vm->node_main;
84 
85  /* Clear the node runtime perfmon counters */
86  for (i = 0; i < vec_len (nm->nodes); i++)
87  {
88  n = nm->nodes[i];
89  vlib_node_sync_stats (stat_vm, n);
90  }
91 
92  /* And clear the node perfmon counters */
93  for (i = 0; i < vec_len (nm->nodes); i++)
94  {
95  n = nm->nodes[i];
102  }
103  }
105 }
106 
107 static void
109 {
110  struct perf_event_attr pe;
111  int fd;
112  struct perf_event_mmap_page *p = 0;
115  u32 my_thread_index = vm->thread_index;
116  u32 index;
117  int i, limit = 1;
118  int cpu;
119 
120  if ((pm->current_event + 1) < vec_len (pm->single_events_to_collect))
121  limit = 2;
122 
123  for (i = 0; i < limit; i++)
124  {
126  pm->current_event + i);
127 
128  memset (&pe, 0, sizeof (struct perf_event_attr));
129  pe.type = c->pe_type;
130  pe.size = sizeof (struct perf_event_attr);
131  pe.config = c->pe_config;
132  pe.disabled = 1;
133  pe.pinned = 1;
134  /*
135  * Note: excluding the kernel makes the
136  * (software) context-switch counter read 0...
137  */
138  if (pe.type != PERF_TYPE_SOFTWARE)
139  {
140  /* Exclude kernel and hypervisor */
141  pe.exclude_kernel = 1;
142  pe.exclude_hv = 1;
143  }
144 
145  cpu = vm->cpu_id;
146 
147  fd = perf_event_open (&pe, 0, cpu, -1, 0);
148  if (fd == -1)
149  {
150  clib_unix_warning ("event open: type %d config %d", c->pe_type,
151  c->pe_config);
152  return;
153  }
154 
155  if (pe.type != PERF_TYPE_SOFTWARE)
156  {
157  p = mmap (0, pm->page_size, PROT_READ, MAP_SHARED, fd, 0);
158  if (p == MAP_FAILED)
159  {
160  clib_unix_warning ("mmap");
161  close (fd);
162  return;
163  }
164  }
165  else
166  p = 0;
167 
168  if (ioctl (fd, PERF_EVENT_IOC_RESET, 0) < 0)
169  clib_unix_warning ("reset ioctl");
170 
171  if (ioctl (fd, PERF_EVENT_IOC_ENABLE, 0) < 0)
172  clib_unix_warning ("enable ioctl");
173 
174  pm->perf_event_pages[i][my_thread_index] = (void *) p;
175  pm->pm_fds[i][my_thread_index] = fd;
176  }
177 
178  /*
179  * Hardware events must be all opened and enabled before aquiring
180  * pmc indices, otherwise the pmc indices might be out-dated.
181  */
182  for (i = 0; i < limit; i++)
183  {
184  p =
185  (struct perf_event_mmap_page *)
186  pm->perf_event_pages[i][my_thread_index];
187 
188  /*
189  * Software event counters - and others not capable of being
190  * read via the "rdpmc" instruction - will be read
191  * by system calls.
192  */
193  if (p == 0 || p->cap_user_rdpmc == 0)
194  index = ~0;
195  else
196  index = p->index - 1;
197 
198  pm->rdpmc_indices[i][my_thread_index] = index;
199  }
200 
201  pm->n_active = i;
202  /* Enable the main loop counter snapshot mechanism */
204 }
205 
206 static void
208 {
210  u32 my_thread_index = vm->thread_index;
211  int i;
212 
213  /* Stop main loop collection */
215 
216  for (i = 0; i < pm->n_active; i++)
217  {
218  if (pm->pm_fds[i][my_thread_index] == 0)
219  continue;
220 
221  if (ioctl (pm->pm_fds[i][my_thread_index], PERF_EVENT_IOC_DISABLE, 0) <
222  0)
223  clib_unix_warning ("disable ioctl");
224 
225  if (pm->perf_event_pages[i][my_thread_index])
226  if (munmap (pm->perf_event_pages[i][my_thread_index],
227  pm->page_size) < 0)
228  clib_unix_warning ("munmap");
229 
230  (void) close (pm->pm_fds[i][my_thread_index]);
231  pm->pm_fds[i][my_thread_index] = 0;
232  }
233 }
234 
235 static void
237 {
239 
242 }
243 
244 static void
246 {
248  disable_events (pm);
250 }
251 
252 static void
253 start_event (perfmon_main_t * pm, f64 now, uword event_data)
254 {
255  int i;
256  int last_set;
257  int all = 0;
258  pm->current_event = 0;
259 
260  if (vec_len (pm->single_events_to_collect) == 0)
261  {
262  pm->state = PERFMON_STATE_OFF;
263  return;
264  }
265 
266  last_set = clib_bitmap_last_set (pm->thread_bitmap);
267  all = (last_set == ~0);
268 
270  clear_counters (pm);
271 
272  /* Start collection on thread 0? */
273  if (all || clib_bitmap_get (pm->thread_bitmap, 0))
274  {
275  /* Start collection on this thread */
277  }
278 
279  /* And also on worker threads */
280  for (i = 1; i < vec_len (vlib_mains); i++)
281  {
282  if (vlib_mains[i] == 0)
283  continue;
284 
285  if (all || clib_bitmap_get (pm->thread_bitmap, i))
286  vlib_mains[i]->worker_thread_main_loop_callback = (void *)
288  }
289 }
290 
291 void
293 {
294  int i, j, k;
295  vlib_main_t *vm = pm->vlib_main;
296  vlib_main_t *stat_vm;
297  vlib_node_main_t *nm;
298  vlib_node_t ***node_dups = 0;
299  vlib_node_t **nodes;
300  vlib_node_t *n;
302  perfmon_event_config_t *current_event;
303  uword *p;
304  u8 *counter_name;
305  u64 vectors_this_counter;
306 
307  /* snapshoot the nodes, including pm counters */
309 
310  for (j = 0; j < vec_len (vlib_mains); j++)
311  {
312  stat_vm = vlib_mains[j];
313  if (stat_vm == 0)
314  continue;
315 
316  nm = &stat_vm->node_main;
317 
318  for (i = 0; i < vec_len (nm->nodes); i++)
319  {
320  n = nm->nodes[i];
321  vlib_node_sync_stats (stat_vm, n);
322  }
323 
324  nodes = 0;
325  vec_validate (nodes, vec_len (nm->nodes) - 1);
326  vec_add1 (node_dups, nodes);
327 
328  /* Snapshoot and clear the per-node perfmon counters */
329  for (i = 0; i < vec_len (nm->nodes); i++)
330  {
331  n = nm->nodes[i];
332  nodes[i] = clib_mem_alloc (sizeof (*n));
333  clib_memcpy_fast (nodes[i], n, sizeof (*n));
340  }
341  }
342 
344 
345  for (j = 0; j < vec_len (vlib_mains); j++)
346  {
347  stat_vm = vlib_mains[j];
348  if (stat_vm == 0)
349  continue;
350 
351  nodes = node_dups[j];
352 
353  for (i = 0; i < vec_len (nodes); i++)
354  {
355  u8 *capture_name;
356 
357  n = nodes[i];
358 
359  if (n->stats_total.perf_counter0_ticks == 0 &&
361  goto skip_this_node;
362 
363  for (k = 0; k < 2; k++)
364  {
365  u64 counter_value, counter_last_clear;
366 
367  /*
368  * We collect 2 counters at once, except for the
369  * last counter when the user asks for an odd number of
370  * counters
371  */
372  if ((pm->current_event + k)
374  break;
375 
376  if (k == 0)
377  {
378  counter_value = n->stats_total.perf_counter0_ticks;
379  counter_last_clear =
381  }
382  else
383  {
384  counter_value = n->stats_total.perf_counter1_ticks;
385  counter_last_clear =
387  }
388 
389  capture_name = format (0, "t%d-%v%c", j, n->name, 0);
390 
392  capture_name);
393 
394  if (p == 0)
395  {
396  pool_get (pm->capture_pool, c);
397  memset (c, 0, sizeof (*c));
398  c->thread_and_node_name = capture_name;
400  capture_name, c - pm->capture_pool);
401  }
402  else
403  {
404  c = pool_elt_at_index (pm->capture_pool, p[0]);
405  vec_free (capture_name);
406  }
407 
408  /* Snapshoot counters, etc. into the capture */
409  current_event = pm->single_events_to_collect
410  + pm->current_event + k;
411  counter_name = (u8 *) current_event->name;
412  vectors_this_counter = n->stats_total.perf_counter_vectors -
414 
415  vec_add1 (c->counter_names, counter_name);
417  counter_value - counter_last_clear);
418  vec_add1 (c->vectors_this_counter, vectors_this_counter);
419  }
420  skip_this_node:
421  clib_mem_free (n);
422  }
423  vec_free (nodes);
424  }
425  vec_free (node_dups);
426 }
427 
428 static void
430 {
431  int i;
432  int last_set, all;
433 
434  last_set = clib_bitmap_last_set (pm->thread_bitmap);
435  all = (last_set == ~0);
436 
437  if (all || clib_bitmap_get (pm->thread_bitmap, 0))
438  disable_events (pm);
439 
440  /* And also on worker threads */
441  for (i = 1; i < vec_len (vlib_mains); i++)
442  {
443  if (vlib_mains[i] == 0)
444  continue;
445  if (all || clib_bitmap_get (pm->thread_bitmap, i))
446  vlib_mains[i]->worker_thread_main_loop_callback = (void *)
448  }
449 
450  /* Make sure workers have stopped collection */
451  if (i > 1)
452  {
453  f64 deadman = vlib_time_now (vm) + 1.0;
454 
455  for (i = 1; i < vec_len (vlib_mains); i++)
456  {
457  /* Has the worker actually stopped collecting data? */
458  while (vlib_mains[i]->worker_thread_main_loop_callback)
459  {
460  if (vlib_time_now (vm) > deadman)
461  {
462  clib_warning ("Thread %d deadman timeout!", i);
463  break;
464  }
465  vlib_process_suspend (pm->vlib_main, 1e-3);
466  }
467  }
468  }
470  pm->current_event += pm->n_active;
471  if (pm->current_event >= vec_len (pm->single_events_to_collect))
472  {
473  pm->current_event = 0;
474  pm->state = PERFMON_STATE_OFF;
475  return;
476  }
477 
478  if (all || clib_bitmap_get (pm->thread_bitmap, 0))
480 
481  /* And also on worker threads */
482  for (i = 1; i < vec_len (vlib_mains); i++)
483  {
484  if (vlib_mains[i] == 0)
485  continue;
486  if (all || clib_bitmap_get (pm->thread_bitmap, i))
487  vlib_mains[i]->worker_thread_main_loop_callback = (void *)
489  }
490 }
491 
492 static uword
495 {
497  f64 now;
498  uword *event_data = 0;
499  uword event_type;
500  int i;
501 
502  while (1)
503  {
504  if (pm->state == PERFMON_STATE_RUNNING)
506  else
508 
509  now = vlib_time_now (vm);
510 
511  event_type = vlib_process_get_events (vm, (uword **) & event_data);
512 
513  switch (event_type)
514  {
515  case PERFMON_START:
516  for (i = 0; i < vec_len (event_data); i++)
517  start_event (pm, now, event_data[i]);
518  break;
519 
520  /* Handle timeout */
521  case ~0:
522  handle_timeout (vm, pm, now);
523  break;
524 
525  default:
526  clib_warning ("Unexpected event %d", event_type);
527  break;
528  }
529  vec_reset_length (event_data);
530  }
531  return 0; /* or not */
532 }
533 
534 /* *INDENT-OFF* */
536 {
537  .function = perfmon_periodic_process,
538  .type = VLIB_NODE_TYPE_PROCESS,
539  .name = "perfmon-periodic-process",
540 };
541 /* *INDENT-ON* */
542 
543 /*
544  * fd.io coding-style-patch-verification: ON
545  *
546  * Local Variables:
547  * eval: (c-set-style "gnu")
548  * End:
549  */
perfmon_capture_t * capture_pool
Definition: perfmon.h:88
#define vec_validate(V, I)
Make sure vector is long enough for given index (no header, unspecified alignment) ...
Definition: vec.h:439
u32 ** rdpmc_indices
Definition: perfmon.h:115
volatile u8 state
Definition: perfmon.h:85
u32 current_event
Definition: perfmon.h:113
f64 timeout_interval
Definition: perfmon.h:110
static void worker_thread_start_event(vlib_main_t *vm)
u32 flags
Definition: vhost_user.h:115
u64 * vectors_this_counter
Definition: perfmon.h:70
int ** pm_fds
Definition: perfmon.h:121
static f64 vlib_process_wait_for_event_or_clock(vlib_main_t *vm, f64 dt)
Suspend a cooperative multi-tasking thread Waits for an event, or for the indicated number of seconds...
Definition: node_funcs.h:673
static uword * vlib_process_wait_for_event(vlib_main_t *vm)
Definition: node_funcs.h:593
static void clear_counters(perfmon_main_t *pm)
unsigned long u64
Definition: types.h:89
static long perf_event_open(struct perf_event_attr *hw_event, pid_t pid, int cpu, int group_fd, unsigned long flags)
#define clib_memcpy_fast(a, b, c)
Definition: string.h:81
static void disable_events(perfmon_main_t *pm)
void(* vlib_node_runtime_perf_counter_cb)(struct vlib_main_t *, u64 *, u64 *)
Definition: main.h:97
static f64 vlib_time_now(vlib_main_t *vm)
Definition: main.h:255
u32 thread_index
Definition: main.h:197
#define vec_add1(V, E)
Add 1 element to end of vector (unspecified alignment).
Definition: vec.h:522
int i
static void enable_current_events(perfmon_main_t *pm)
#define hash_set_mem(h, key, value)
Definition: hash.h:275
u8 * format(u8 *s, const char *fmt,...)
Definition: format.c:424
vlib_main_t * vlib_main
Definition: perfmon.h:130
#define pool_get(P, E)
Allocate an object E from a pool P (unspecified alignment).
Definition: pool.h:236
vlib_main_t ** vlib_mains
Definition: buffer.c:321
unsigned char u8
Definition: types.h:56
#define vec_reset_length(v)
Reset vector length to zero NULL-pointer tolerant.
u64 perf_counter0_ticks
Definition: node.h:235
double f64
Definition: types.h:142
#define vlib_worker_thread_barrier_sync(X)
Definition: threads.h:204
static uword vlib_process_suspend(vlib_main_t *vm, f64 dt)
Suspend a vlib cooperative multi-tasking thread for a period of time.
Definition: node_funcs.h:422
vlib_node_stats_t stats_last_clear
Definition: node.h:273
static uword vlib_process_get_events(vlib_main_t *vm, uword **data_vector)
Return the first event type which has occurred and a vector of per-event data of that type...
Definition: node_funcs.h:516
vlib_node_t ** nodes
Definition: node.h:697
#define vec_elt_at_index(v, i)
Get vector value at index i checking that i is in bounds.
u64 perf_counter_vectors
Definition: node.h:237
u32 cpu_id
Definition: main.h:198
u8 * thread_and_node_name
Definition: perfmon.h:67
unsigned int u32
Definition: types.h:88
static void read_current_perf_counters(vlib_main_t *vm, u64 *c0, u64 *c1)
void scrape_and_clear_counters(perfmon_main_t *pm)
#define pool_elt_at_index(p, i)
Returns pointer to element at given index.
Definition: pool.h:514
vlib_node_stats_t stats_total
Definition: node.h:269
u8 ** counter_names
Definition: perfmon.h:68
static uword clib_bitmap_last_set(uword *ai)
Return the higest numbered set bit in a bitmap.
Definition: bitmap.h:423
u8 * name
Definition: node.h:263
static void worker_thread_stop_event(vlib_main_t *vm)
#define VLIB_REGISTER_NODE(x,...)
Definition: node.h:169
svmdb_client_t * c
static void handle_timeout(vlib_main_t *vm, perfmon_main_t *pm, f64 now)
vlib_main_t * vm
Definition: buffer.c:312
#define vec_free(V)
Free vector&#39;s memory (no header).
Definition: vec.h:341
#define clib_warning(format, args...)
Definition: error.h:59
static uword clib_bitmap_get(uword *ai, uword i)
Gets the ith bit value from a bitmap.
Definition: bitmap.h:197
u64 perf_counter1_ticks
Definition: node.h:236
static void clib_mem_free(void *p)
Definition: mem.h:205
perfmon_event_config_t * single_events_to_collect
Definition: perfmon.h:100
static u64 clib_rdpmc(int counter_id)
Definition: pmc.h:22
perfmon_main_t perfmon_main
Definition: perfmon.c:28
static void * clib_mem_alloc(uword size)
Definition: mem.h:132
static vlib_main_t * vlib_get_main(void)
Definition: global_funcs.h:23
uword * capture_by_thread_and_node_name
Definition: perfmon.h:89
static void start_event(perfmon_main_t *pm, f64 now, uword event_data)
void vlib_node_sync_stats(vlib_main_t *vm, vlib_node_t *n)
Definition: main.c:586
uword * thread_bitmap
Definition: perfmon.h:124
#define vec_len(v)
Number of elements in vector (rvalue-only, NULL tolerant)
u8 *** perf_event_pages
Definition: perfmon.h:117
u64 * counter_values
Definition: perfmon.h:69
vlib_node_main_t node_main
Definition: main.h:135
u64 uword
Definition: types.h:112
#define clib_unix_warning(format, args...)
Definition: error.h:68
#define hash_get_mem(h, key)
Definition: hash.h:269
void vlib_worker_thread_barrier_release(vlib_main_t *vm)
Definition: threads.c:1489
static uword perfmon_periodic_process(vlib_main_t *vm, vlib_node_runtime_t *rt, vlib_frame_t *f)
volatile void(* worker_thread_main_loop_callback)(struct vlib_main_t *)
Definition: main.h:216
vlib_node_registration_t perfmon_periodic_node
(constructor) VLIB_REGISTER_NODE (perfmon_periodic_node)
#define PERFMON_START
Definition: perfmon.h:141