tools/testing/selftests/bpf/benchs/bench_local_storage_create.c

   1 // SPDX-License-Identifier: GPL-2.0
   2 /* Copyright (c) 2023 Meta Platforms, Inc. and affiliates. */
   3
   4 #include <sys/types.h>
   5 #include <sys/socket.h>
   6 #include <pthread.h>
   7 #include <argp.h>
   8
   9 #include "bench.h"
  10 #include "bench_local_storage_create.skel.h"
  11
  12 struct thread {
  13         int *fds;
  14         pthread_t *pthds;
  15         int *pthd_results;
  16 };
  17
  18 static struct bench_local_storage_create *skel;
  19 static struct thread *threads;
  20 static long create_owner_errs;
  21 static int storage_type = BPF_MAP_TYPE_SK_STORAGE;
  22 static int batch_sz = 32;
  23
  24 enum {
  25         ARG_BATCH_SZ = 9000,
  26         ARG_STORAGE_TYPE = 9001,
  27 };
  28
  29 static const struct argp_option opts[] = {
  30         { "batch-size", ARG_BATCH_SZ, "BATCH_SIZE", 0,
  31           "The number of storage creations in each batch" },
  32         { "storage-type", ARG_STORAGE_TYPE, "STORAGE_TYPE", 0,
  33           "The type of local storage to test (socket or task)" },
  34         {},
  35 };
  36
  37 static error_t parse_arg(int key, char *arg, struct argp_state *state)
  38 {
  39         int ret;
  40
  41         switch (key) {
  42         case ARG_BATCH_SZ:
  43                 ret = atoi(arg);
  44                 if (ret < 1) {
  45                         fprintf(stderr, "invalid batch-size\n");
  46                         argp_usage(state);
  47                 }
  48                 batch_sz = ret;
  49                 break;
  50         case ARG_STORAGE_TYPE:
  51                 if (!strcmp(arg, "task")) {
  52                         storage_type = BPF_MAP_TYPE_TASK_STORAGE;
  53                 } else if (!strcmp(arg, "socket")) {
  54                         storage_type = BPF_MAP_TYPE_SK_STORAGE;
  55                 } else {
  56                         fprintf(stderr, "invalid storage-type (socket or task)\n");
  57                         argp_usage(state);
  58                 }
  59                 break;
  60         default:
  61                 return ARGP_ERR_UNKNOWN;
  62         }
  63
  64         return 0;
  65 }
  66
  67 const struct argp bench_local_storage_create_argp = {
  68         .options = opts,
  69         .parser = parse_arg,
  70 };
  71
  72 static void validate(void)
  73 {
  74         if (env.consumer_cnt != 0) {
  75                 fprintf(stderr,
  76                         "local-storage-create benchmark does not need consumer\n");
  77                 exit(1);
  78         }
  79 }
  80
  81 static void setup(void)
  82 {
  83         int i;
  84
  85         skel = bench_local_storage_create__open_and_load();
  86         if (!skel) {
  87                 fprintf(stderr, "error loading skel\n");
  88                 exit(1);
  89         }
  90
  91         skel->bss->bench_pid = getpid();
  92         if (storage_type == BPF_MAP_TYPE_SK_STORAGE) {
  93                 if (!bpf_program__attach(skel->progs.socket_post_create)) {
  94                         fprintf(stderr, "Error attaching bpf program\n");
  95                         exit(1);
  96                 }
  97         } else {
  98                 if (!bpf_program__attach(skel->progs.sched_process_fork)) {
  99                         fprintf(stderr, "Error attaching bpf program\n");
 100                         exit(1);
 101                 }
 102         }
 103
 104         if (!bpf_program__attach(skel->progs.kmalloc)) {
 105                 fprintf(stderr, "Error attaching bpf program\n");
 106                 exit(1);
 107         }
 108
 109         threads = calloc(env.producer_cnt, sizeof(*threads));
 110
 111         if (!threads) {
 112                 fprintf(stderr, "cannot alloc thread_res\n");
 113                 exit(1);
 114         }
 115
 116         for (i = 0; i < env.producer_cnt; i++) {
 117                 struct thread *t = &threads[i];
 118
 119                 if (storage_type == BPF_MAP_TYPE_SK_STORAGE) {
 120                         t->fds = malloc(batch_sz * sizeof(*t->fds));
 121                         if (!t->fds) {
 122                                 fprintf(stderr, "cannot alloc t->fds\n");
 123                                 exit(1);
 124                         }
 125                 } else {
 126                         t->pthds = malloc(batch_sz * sizeof(*t->pthds));
 127                         if (!t->pthds) {
 128                                 fprintf(stderr, "cannot alloc t->pthds\n");
 129                                 exit(1);
 130                         }
 131                         t->pthd_results = malloc(batch_sz * sizeof(*t->pthd_results));
 132                         if (!t->pthd_results) {
 133                                 fprintf(stderr, "cannot alloc t->pthd_results\n");
 134                                 exit(1);
 135                         }
 136                 }
 137         }
 138 }
 139
 140 static void measure(struct bench_res *res)
 141 {
 142         res->hits = atomic_swap(&skel->bss->create_cnts, 0);
 143         res->drops = atomic_swap(&skel->bss->kmalloc_cnts, 0);
 144 }
 145
 146 static void *sk_producer(void *input)
 147 {
 148         struct thread *t = &threads[(long)(input)];
 149         int *fds = t->fds;
 150         int i;
 151
 152         while (true) {
 153                 for (i = 0; i < batch_sz; i++) {
 154                         fds[i] = socket(AF_INET6, SOCK_DGRAM, 0);
 155                         if (fds[i] == -1)
 156                                 atomic_inc(&create_owner_errs);
 157                 }
 158
 159                 for (i = 0; i < batch_sz; i++) {
 160                         if (fds[i] != -1)
 161                                 close(fds[i]);
 162                 }
 163         }
 164
 165         return NULL;
 166 }
 167
 168 static void *thread_func(void *arg)
 169 {
 170         return NULL;
 171 }
 172
 173 static void *task_producer(void *input)
 174 {
 175         struct thread *t = &threads[(long)(input)];
 176         pthread_t *pthds = t->pthds;
 177         int *pthd_results = t->pthd_results;
 178         int i;
 179
 180         while (true) {
 181                 for (i = 0; i < batch_sz; i++) {
 182                         pthd_results[i] = pthread_create(&pthds[i], NULL, thread_func, NULL);
 183                         if (pthd_results[i])
 184                                 atomic_inc(&create_owner_errs);
 185                 }
 186
 187                 for (i = 0; i < batch_sz; i++) {
 188                         if (!pthd_results[i])
 189                                 pthread_join(pthds[i], NULL);
 190                 }
 191         }
 192
 193         return NULL;
 194 }
 195
 196 static void *producer(void *input)
 197 {
 198         if (storage_type == BPF_MAP_TYPE_SK_STORAGE)
 199                 return sk_producer(input);
 200         else
 201                 return task_producer(input);
 202 }
 203
 204 static void report_progress(int iter, struct bench_res *res, long delta_ns)
 205 {
 206         double creates_per_sec, kmallocs_per_create;
 207
 208         creates_per_sec = res->hits / 1000.0 / (delta_ns / 1000000000.0);
 209         kmallocs_per_create = (double)res->drops / res->hits;
 210
 211         printf("Iter %3d (%7.3lfus): ",
 212                iter, (delta_ns - 1000000000) / 1000.0);
 213         printf("creates %8.3lfk/s (%7.3lfk/prod), ",
 214                creates_per_sec, creates_per_sec / env.producer_cnt);
 215         printf("%3.2lf kmallocs/create\n", kmallocs_per_create);
 216 }
 217
 218 static void report_final(struct bench_res res[], int res_cnt)
 219 {
 220         double creates_mean = 0.0, creates_stddev = 0.0;
 221         long total_creates = 0, total_kmallocs = 0;
 222         int i;
 223
 224         for (i = 0; i < res_cnt; i++) {
 225                 creates_mean += res[i].hits / 1000.0 / (0.0 + res_cnt);
 226                 total_creates += res[i].hits;
 227                 total_kmallocs += res[i].drops;
 228         }
 229
 230         if (res_cnt > 1)  {
 231                 for (i = 0; i < res_cnt; i++)
 232                         creates_stddev += (creates_mean - res[i].hits / 1000.0) *
 233                                        (creates_mean - res[i].hits / 1000.0) /
 234                                        (res_cnt - 1.0);
 235                 creates_stddev = sqrt(creates_stddev);
 236         }
 237         printf("Summary: creates %8.3lf \u00B1 %5.3lfk/s (%7.3lfk/prod), ",
 238                creates_mean, creates_stddev, creates_mean / env.producer_cnt);
 239         printf("%4.2lf kmallocs/create\n", (double)total_kmallocs / total_creates);
 240         if (create_owner_errs || skel->bss->create_errs)
 241                 printf("%s() errors %ld create_errs %ld\n",
 242                        storage_type == BPF_MAP_TYPE_SK_STORAGE ?
 243                        "socket" : "pthread_create",
 244                        create_owner_errs,
 245                        skel->bss->create_errs);
 246 }
 247
 248 /* Benchmark performance of creating bpf local storage  */
 249 const struct bench bench_local_storage_create = {
 250         .name = "local-storage-create",
 251         .argp = &bench_local_storage_create_argp,
 252         .validate = validate,
 253         .setup = setup,
 254         .producer_thread = producer,
 255         .measure = measure,
 256         .report_progress = report_progress,
 257         .report_final = report_final,
 258 };