1 // SPDX-License-Identifier: GPL-2.0
2 /* Copyright (c) 2020 Facebook */
3 #include <asm/barrier.h>
4 #include <linux/perf_event.h>
5 #include <linux/ring_buffer.h>
6 #include <sys/epoll.h>
7 #include <sys/mman.h>
8 #include <argp.h>
9 #include <stdlib.h>
10 #include "bench.h"
11 #include "ringbuf_bench.skel.h"
12 #include "perfbuf_bench.skel.h"
13
14 static struct {
15 bool back2back;
16 int batch_cnt;
17 bool sampled;
18 int sample_rate;
19 int ringbuf_sz; /* per-ringbuf, in bytes */
20 bool ringbuf_use_output; /* use slower output API */
21 int perfbuf_sz; /* per-CPU size, in pages */
22 } args = {
23 .back2back = false,
24 .batch_cnt = 500,
25 .sampled = false,
26 .sample_rate = 500,
27 .ringbuf_sz = 512 * 1024,
28 .ringbuf_use_output = false,
29 .perfbuf_sz = 128,
30 };
31
32 enum {
33 ARG_RB_BACK2BACK = 2000,
34 ARG_RB_USE_OUTPUT = 2001,
35 ARG_RB_BATCH_CNT = 2002,
36 ARG_RB_SAMPLED = 2003,
37 ARG_RB_SAMPLE_RATE = 2004,
38 };
39
40 static const struct argp_option opts[] = {
41 { "rb-b2b", ARG_RB_BACK2BACK, NULL, 0, "Back-to-back mode"},
42 { "rb-use-output", ARG_RB_USE_OUTPUT, NULL, 0, "Use bpf_ringbuf_output() instead of bpf_ringbuf_reserve()"},
43 { "rb-batch-cnt", ARG_RB_BATCH_CNT, "CNT", 0, "Set BPF-side record batch count"},
44 { "rb-sampled", ARG_RB_SAMPLED, NULL, 0, "Notification sampling"},
45 { "rb-sample-rate", ARG_RB_SAMPLE_RATE, "RATE", 0, "Notification sample rate"},
46 {},
47 };
48
49 static error_t parse_arg(int key, char *arg, struct argp_state *state)
50 {
51 switch (key) {
52 case ARG_RB_BACK2BACK:
53 args.back2back = true;
54 break;
55 case ARG_RB_USE_OUTPUT:
56 args.ringbuf_use_output = true;
57 break;
58 case ARG_RB_BATCH_CNT:
59 args.batch_cnt = strtol(arg, NULL, 10);
60 if (args.batch_cnt < 0) {
61 fprintf(stderr, "Invalid batch count.");
62 argp_usage(state);
63 }
64 break;
65 case ARG_RB_SAMPLED:
66 args.sampled = true;
67 break;
68 case ARG_RB_SAMPLE_RATE:
69 args.sample_rate = strtol(arg, NULL, 10);
70 if (args.sample_rate < 0) {
71 fprintf(stderr, "Invalid perfbuf sample rate.");
72 argp_usage(state);
73 }
74 break;
75 default:
76 return ARGP_ERR_UNKNOWN;
77 }
78 return 0;
79 }
80
81 /* exported into benchmark runner */
82 const struct argp bench_ringbufs_argp = {
83 .options = opts,
84 .parser = parse_arg,
85 };
86
87 /* RINGBUF-LIBBPF benchmark */
88
89 static struct counter buf_hits;
90
91 static inline void bufs_trigger_batch(void)
92 {
93 (void)syscall(__NR_getpgid);
94 }
95
96 static void bufs_validate(void)
97 {
98 if (env.consumer_cnt != 1) {
99 fprintf(stderr, "rb-libbpf benchmark needs one consumer!\n");
100 exit(1);
101 }
102
103 if (args.back2back && env.producer_cnt > 1) {
104 fprintf(stderr, "back-to-back mode makes sense only for single-producer case!\n");
105 exit(1);
106 }
107 }
108
109 static void *bufs_sample_producer(void *input)
110 {
111 if (args.back2back) {
112 /* initial batch to get everything started */
113 bufs_trigger_batch();
114 return NULL;
115 }
116
117 while (true)
118 bufs_trigger_batch();
119 return NULL;
120 }
121
122 static struct ringbuf_libbpf_ctx {
123 struct ringbuf_bench *skel;
124 struct ring_buffer *ringbuf;
125 } ringbuf_libbpf_ctx;
126
127 static void ringbuf_libbpf_measure(struct bench_res *res)
128 {
129 struct ringbuf_libbpf_ctx *ctx = &ringbuf_libbpf_ctx;
130
131 res->hits = atomic_swap(&buf_hits.value, 0);
132 res->drops = atomic_swap(&ctx->skel->bss->dropped, 0);
133 }
134
135 static struct ringbuf_bench *ringbuf_setup_skeleton(void)
136 {
137 struct ringbuf_bench *skel;
138
139 setup_libbpf();
140
141 skel = ringbuf_bench__open();
142 if (!skel) {
143 fprintf(stderr, "failed to open skeleton\n");
144 exit(1);
145 }
146
147 skel->rodata->batch_cnt = args.batch_cnt;
148 skel->rodata->use_output = args.ringbuf_use_output ? 1 : 0;
149
150 if (args.sampled)
151 /* record data + header take 16 bytes */
152 skel->rodata->wakeup_data_size = args.sample_rate * 16;
153
154 bpf_map__set_max_entries(skel->maps.ringbuf, args.ringbuf_sz);
155
156 if (ringbuf_bench__load(skel)) {
157 fprintf(stderr, "failed to load skeleton\n");
158 exit(1);
159 }
160
161 return skel;
162 }
163
164 static int buf_process_sample(void *ctx, void *data, size_t len)
165 {
166 atomic_inc(&buf_hits.value);
167 return 0;
168 }
169
170 static void ringbuf_libbpf_setup(void)
171 {
172 struct ringbuf_libbpf_ctx *ctx = &ringbuf_libbpf_ctx;
173 struct bpf_link *link;
174
175 ctx->skel = ringbuf_setup_skeleton();
176 ctx->ringbuf = ring_buffer__new(bpf_map__fd(ctx->skel->maps.ringbuf),
177 buf_process_sample, NULL, NULL);
178 if (!ctx->ringbuf) {
179 fprintf(stderr, "failed to create ringbuf\n");
180 exit(1);
181 }
182
183 link = bpf_program__attach(ctx->skel->progs.bench_ringbuf);
184 if (!link) {
185 fprintf(stderr, "failed to attach program!\n");
186 exit(1);
187 }
188 }
189
190 static void *ringbuf_libbpf_consumer(void *input)
191 {
192 struct ringbuf_libbpf_ctx *ctx = &ringbuf_libbpf_ctx;
193
194 while (ring_buffer__poll(ctx->ringbuf, -1) >= 0) {
195 if (args.back2back)
196 bufs_trigger_batch();
197 }
198 fprintf(stderr, "ringbuf polling failed!\n");
199 return NULL;
200 }
201
202 /* RINGBUF-CUSTOM benchmark */
203 struct ringbuf_custom {
204 __u64 *consumer_pos;
205 __u64 *producer_pos;
206 __u64 mask;
207 void *data;
208 int map_fd;
209 };
210
211 static struct ringbuf_custom_ctx {
212 struct ringbuf_bench *skel;
213 struct ringbuf_custom ringbuf;
214 int epoll_fd;
215 struct epoll_event event;
216 } ringbuf_custom_ctx;
217
218 static void ringbuf_custom_measure(struct bench_res *res)
219 {
220 struct ringbuf_custom_ctx *ctx = &ringbuf_custom_ctx;
221
222 res->hits = atomic_swap(&buf_hits.value, 0);
223 res->drops = atomic_swap(&ctx->skel->bss->dropped, 0);
224 }
225
226 static void ringbuf_custom_setup(void)
227 {
228 struct ringbuf_custom_ctx *ctx = &ringbuf_custom_ctx;
229 const size_t page_size = getpagesize();
230 struct bpf_link *link;
231 struct ringbuf_custom *r;
232 void *tmp;
233 int err;
234
235 ctx->skel = ringbuf_setup_skeleton();
236
237 ctx->epoll_fd = epoll_create1(EPOLL_CLOEXEC);
238 if (ctx->epoll_fd < 0) {
239 fprintf(stderr, "failed to create epoll fd: %d\n", -errno);
240 exit(1);
241 }
242
243 r = &ctx->ringbuf;
244 r->map_fd = bpf_map__fd(ctx->skel->maps.ringbuf);
245 r->mask = args.ringbuf_sz - 1;
246
247 /* Map writable consumer page */
248 tmp = mmap(NULL, page_size, PROT_READ | PROT_WRITE, MAP_SHARED,
249 r->map_fd, 0);
250 if (tmp == MAP_FAILED) {
251 fprintf(stderr, "failed to mmap consumer page: %d\n", -errno);
252 exit(1);
253 }
254 r->consumer_pos = tmp;
255
256 /* Map read-only producer page and data pages. */
257 tmp = mmap(NULL, page_size + 2 * args.ringbuf_sz, PROT_READ, MAP_SHARED,
258 r->map_fd, page_size);
259 if (tmp == MAP_FAILED) {
260 fprintf(stderr, "failed to mmap data pages: %d\n", -errno);
261 exit(1);
262 }
263 r->producer_pos = tmp;
264 r->data = tmp + page_size;
265
266 ctx->event.events = EPOLLIN;
267 err = epoll_ctl(ctx->epoll_fd, EPOLL_CTL_ADD, r->map_fd, &ctx->event);
268 if (err < 0) {
269 fprintf(stderr, "failed to epoll add ringbuf: %d\n", -errno);
270 exit(1);
271 }
272
273 link = bpf_program__attach(ctx->skel->progs.bench_ringbuf);
274 if (!link) {
275 fprintf(stderr, "failed to attach program\n");
276 exit(1);
277 }
278 }
279
280 #define RINGBUF_BUSY_BIT (1 << 31)
281 #define RINGBUF_DISCARD_BIT (1 << 30)
282 #define RINGBUF_META_LEN 8
283
284 static inline int roundup_len(__u32 len)
285 {
286 /* clear out top 2 bits */
287 len <<= 2;
288 len >>= 2;
289 /* add length prefix */
290 len += RINGBUF_META_LEN;
291 /* round up to 8 byte alignment */
292 return (len + 7) / 8 * 8;
293 }
294
295 static void ringbuf_custom_process_ring(struct ringbuf_custom *r)
296 {
297 unsigned long cons_pos, prod_pos;
298 int *len_ptr, len;
299 bool got_new_data;
300
301 cons_pos = smp_load_acquire(r->consumer_pos);
302 while (true) {
303 got_new_data = false;
304 prod_pos = smp_load_acquire(r->producer_pos);
305 while (cons_pos < prod_pos) {
306 len_ptr = r->data + (cons_pos & r->mask);
307 len = smp_load_acquire(len_ptr);
308
309 /* sample not committed yet, bail out for now */
310 if (len & RINGBUF_BUSY_BIT)
311 return;
312
313 got_new_data = true;
314 cons_pos += roundup_len(len);
315
316 atomic_inc(&buf_hits.value);
317 }
318 if (got_new_data)
319 smp_store_release(r->consumer_pos, cons_pos);
320 else
321 break;
322 }
323 }
324
325 static void *ringbuf_custom_consumer(void *input)
326 {
327 struct ringbuf_custom_ctx *ctx = &ringbuf_custom_ctx;
328 int cnt;
329
330 do {
331 if (args.back2back)
332 bufs_trigger_batch();
333 cnt = epoll_wait(ctx->epoll_fd, &ctx->event, 1, -1);
334 if (cnt > 0)
335 ringbuf_custom_process_ring(&ctx->ringbuf);
336 } while (cnt >= 0);
337 fprintf(stderr, "ringbuf polling failed!\n");
338 return 0;
339 }
340
341 /* PERFBUF-LIBBPF benchmark */
342 static struct perfbuf_libbpf_ctx {
343 struct perfbuf_bench *skel;
344 struct perf_buffer *perfbuf;
345 } perfbuf_libbpf_ctx;
346
347 static void perfbuf_measure(struct bench_res *res)
348 {
349 struct perfbuf_libbpf_ctx *ctx = &perfbuf_libbpf_ctx;
350
351 res->hits = atomic_swap(&buf_hits.value, 0);
352 res->drops = atomic_swap(&ctx->skel->bss->dropped, 0);
353 }
354
355 static struct perfbuf_bench *perfbuf_setup_skeleton(void)
356 {
357 struct perfbuf_bench *skel;
358
359 setup_libbpf();
360
361 skel = perfbuf_bench__open();
362 if (!skel) {
363 fprintf(stderr, "failed to open skeleton\n");
364 exit(1);
365 }
366
367 skel->rodata->batch_cnt = args.batch_cnt;
368
369 if (perfbuf_bench__load(skel)) {
370 fprintf(stderr, "failed to load skeleton\n");
371 exit(1);
372 }
373
374 return skel;
375 }
376
377 static enum bpf_perf_event_ret
378 perfbuf_process_sample_raw(void *input_ctx, int cpu,
379 struct perf_event_header *e)
380 {
381 switch (e->type) {
382 case PERF_RECORD_SAMPLE:
383 atomic_inc(&buf_hits.value);
384 break;
385 case PERF_RECORD_LOST:
386 break;
387 default:
388 return LIBBPF_PERF_EVENT_ERROR;
389 }
390 return LIBBPF_PERF_EVENT_CONT;
391 }
392
393 static void perfbuf_libbpf_setup(void)
394 {
395 struct perfbuf_libbpf_ctx *ctx = &perfbuf_libbpf_ctx;
396 struct perf_event_attr attr;
397 struct bpf_link *link;
398
399 ctx->skel = perfbuf_setup_skeleton();
400
401 memset(&attr, 0, sizeof(attr));
402 attr.config = PERF_COUNT_SW_BPF_OUTPUT;
403 attr.type = PERF_TYPE_SOFTWARE;
404 attr.sample_type = PERF_SAMPLE_RAW;
405 /* notify only every Nth sample */
406 if (args.sampled) {
407 attr.sample_period = args.sample_rate;
408 attr.wakeup_events = args.sample_rate;
409 } else {
410 attr.sample_period = 1;
411 attr.wakeup_events = 1;
412 }
413
414 if (args.sample_rate > args.batch_cnt) {
415 fprintf(stderr, "sample rate %d is too high for given batch count %d\n",
416 args.sample_rate, args.batch_cnt);
417 exit(1);
418 }
419
420 ctx->perfbuf = perf_buffer__new_raw(bpf_map__fd(ctx->skel->maps.perfbuf),
421 args.perfbuf_sz, &attr,
422 perfbuf_process_sample_raw, NULL, NULL);
423 if (!ctx->perfbuf) {
424 fprintf(stderr, "failed to create perfbuf\n");
425 exit(1);
426 }
427
428 link = bpf_program__attach(ctx->skel->progs.bench_perfbuf);
429 if (!link) {
430 fprintf(stderr, "failed to attach program\n");
431 exit(1);
432 }
433 }
434
435 static void *perfbuf_libbpf_consumer(void *input)
436 {
437 struct perfbuf_libbpf_ctx *ctx = &perfbuf_libbpf_ctx;
438
439 while (perf_buffer__poll(ctx->perfbuf, -1) >= 0) {
440 if (args.back2back)
441 bufs_trigger_batch();
442 }
443 fprintf(stderr, "perfbuf polling failed!\n");
444 return NULL;
445 }
446
447 /* PERFBUF-CUSTOM benchmark */
448
449 /* copies of internal libbpf definitions */
450 struct perf_cpu_buf {
451 struct perf_buffer *pb;
452 void *base; /* mmap()'ed memory */
453 void *buf; /* for reconstructing segmented data */
454 size_t buf_size;
455 int fd;
456 int cpu;
457 int map_key;
458 };
459
460 struct perf_buffer {
461 perf_buffer_event_fn event_cb;
462 perf_buffer_sample_fn sample_cb;
463 perf_buffer_lost_fn lost_cb;
464 void *ctx; /* passed into callbacks */
465
466 size_t page_size;
467 size_t mmap_size;
468 struct perf_cpu_buf **cpu_bufs;
469 struct epoll_event *events;
470 int cpu_cnt; /* number of allocated CPU buffers */
471 int epoll_fd; /* perf event FD */
472 int map_fd; /* BPF_MAP_TYPE_PERF_EVENT_ARRAY BPF map FD */
473 };
474
475 static void *perfbuf_custom_consumer(void *input)
476 {
477 struct perfbuf_libbpf_ctx *ctx = &perfbuf_libbpf_ctx;
478 struct perf_buffer *pb = ctx->perfbuf;
479 struct perf_cpu_buf *cpu_buf;
480 struct perf_event_mmap_page *header;
481 size_t mmap_mask = pb->mmap_size - 1;
482 struct perf_event_header *ehdr;
483 __u64 data_head, data_tail;
484 size_t ehdr_size;
485 void *base;
486 int i, cnt;
487
488 while (true) {
489 if (args.back2back)
490 bufs_trigger_batch();
491 cnt = epoll_wait(pb->epoll_fd, pb->events, pb->cpu_cnt, -1);
492 if (cnt <= 0) {
493 fprintf(stderr, "perf epoll failed: %d\n", -errno);
494 exit(1);
495 }
496
497 for (i = 0; i < cnt; ++i) {
498 cpu_buf = pb->events[i].data.ptr;
499 header = cpu_buf->base;
500 base = ((void *)header) + pb->page_size;
501
502 data_head = ring_buffer_read_head(header);
503 data_tail = header->data_tail;
504 while (data_head != data_tail) {
505 ehdr = base + (data_tail & mmap_mask);
506 ehdr_size = ehdr->size;
507
508 if (ehdr->type == PERF_RECORD_SAMPLE)
509 atomic_inc(&buf_hits.value);
510
511 data_tail += ehdr_size;
512 }
513 ring_buffer_write_tail(header, data_tail);
514 }
515 }
516 return NULL;
517 }
518
519 const struct bench bench_rb_libbpf = {
520 .name = "rb-libbpf",
521 .argp = &bench_ringbufs_argp,
522 .validate = bufs_validate,
523 .setup = ringbuf_libbpf_setup,
524 .producer_thread = bufs_sample_producer,
525 .consumer_thread = ringbuf_libbpf_consumer,
526 .measure = ringbuf_libbpf_measure,
527 .report_progress = hits_drops_report_progress,
528 .report_final = hits_drops_report_final,
529 };
530
531 const struct bench bench_rb_custom = {
532 .name = "rb-custom",
533 .argp = &bench_ringbufs_argp,
534 .validate = bufs_validate,
535 .setup = ringbuf_custom_setup,
536 .producer_thread = bufs_sample_producer,
537 .consumer_thread = ringbuf_custom_consumer,
538 .measure = ringbuf_custom_measure,
539 .report_progress = hits_drops_report_progress,
540 .report_final = hits_drops_report_final,
541 };
542
543 const struct bench bench_pb_libbpf = {
544 .name = "pb-libbpf",
545 .argp = &bench_ringbufs_argp,
546 .validate = bufs_validate,
547 .setup = perfbuf_libbpf_setup,
548 .producer_thread = bufs_sample_producer,
549 .consumer_thread = perfbuf_libbpf_consumer,
550 .measure = perfbuf_measure,
551 .report_progress = hits_drops_report_progress,
552 .report_final = hits_drops_report_final,
553 };
554
555 const struct bench bench_pb_custom = {
556 .name = "pb-custom",
557 .argp = &bench_ringbufs_argp,
558 .validate = bufs_validate,
559 .setup = perfbuf_libbpf_setup,
560 .producer_thread = bufs_sample_producer,
561 .consumer_thread = perfbuf_custom_consumer,
562 .measure = perfbuf_measure,
563 .report_progress = hits_drops_report_progress,
564 .report_final = hits_drops_report_final,
565 };
566
567
Linux® is a registered trademark of Linus Torvalds in the United States and other countries.
TOMOYO® is a registered trademark of NTT DATA CORPORATION.