selftests/bpf: Add benchmark for local_storage get

author Dave Marchevsky <davemarchevsky@fb.com>

Mon, 20 Jun 2022 22:25:54 +0000 (15:25 -0700)

committer Alexei Starovoitov <ast@kernel.org>

Thu, 23 Jun 2022 02:14:33 +0000 (19:14 -0700)
author Dave Marchevsky <davemarchevsky@fb.com>
Mon, 20 Jun 2022 22:25:54 +0000 (15:25 -0700)
committer Alexei Starovoitov <ast@kernel.org>
Thu, 23 Jun 2022 02:14:33 +0000 (19:14 -0700)
diff --git a/tools/testing/selftests/bpf/Makefile b/tools/testing/selftests/bpf/Makefile

index cb8e552..4fbd88a 100644 (file)
--- a/tools/testing/selftests/bpf/Makefile
+++ b/tools/testing/selftests/bpf/Makefile
@@ -571,6 +571,7 @@ $(OUTPUT)/bench_bloom_filter_map.o: $(OUTPUT)/bloom_filter_bench.skel.h
  $(OUTPUT)/bench_bpf_loop.o: $(OUTPUT)/bpf_loop_bench.skel.h
  $(OUTPUT)/bench_strncmp.o: $(OUTPUT)/strncmp_bench.skel.h
  $(OUTPUT)/bench_bpf_hashmap_full_update.o: $(OUTPUT)/bpf_hashmap_full_update_bench.skel.h
+$(OUTPUT)/bench_local_storage.o: $(OUTPUT)/local_storage_bench.skel.h
  $(OUTPUT)/bench.o: bench.h testing_helpers.h $(BPFOBJ)
  $(OUTPUT)/bench: LDLIBS += -lm
  $(OUTPUT)/bench: $(OUTPUT)/bench.o \
@@ -583,7 +584,8 @@ $(OUTPUT)/bench: $(OUTPUT)/bench.o \
                  $(OUTPUT)/bench_bloom_filter_map.o \
                  $(OUTPUT)/bench_bpf_loop.o \
                  $(OUTPUT)/bench_strncmp.o \
-                $(OUTPUT)/bench_bpf_hashmap_full_update.o
+                $(OUTPUT)/bench_bpf_hashmap_full_update.o \
+                $(OUTPUT)/bench_local_storage.o
         $(call msg,BINARY,,$@)
         $(Q)$(CC) $(CFLAGS) $(LDFLAGS) $(filter %.a %.o,$^) $(LDLIBS) -o $@
  
diff --git a/tools/testing/selftests/bpf/bench.c b/tools/testing/selftests/bpf/bench.c

index d8aa62b..1e7b5d4 100644 (file)
--- a/tools/testing/selftests/bpf/bench.c
+++ b/tools/testing/selftests/bpf/bench.c
@@ -150,6 +150,53 @@ void ops_report_final(struct bench_res res[], int res_cnt)
         printf("latency %8.3lf ns/op\n", 1000.0 / hits_mean * env.producer_cnt);
  }
  
+void local_storage_report_progress(int iter, struct bench_res *res,
+                                  long delta_ns)
+{
+       double important_hits_per_sec, hits_per_sec;
+       double delta_sec = delta_ns / 1000000000.0;
+
+       hits_per_sec = res->hits / 1000000.0 / delta_sec;
+       important_hits_per_sec = res->important_hits / 1000000.0 / delta_sec;
+
+       printf("Iter %3d (%7.3lfus): ", iter, (delta_ns - 1000000000) / 1000.0);
+
+       printf("hits %8.3lfM/s ", hits_per_sec);
+       printf("important_hits %8.3lfM/s\n", important_hits_per_sec);
+}
+
+void local_storage_report_final(struct bench_res res[], int res_cnt)
+{
+       double important_hits_mean = 0.0, important_hits_stddev = 0.0;
+       double hits_mean = 0.0, hits_stddev = 0.0;
+       int i;
+
+       for (i = 0; i < res_cnt; i++) {
+               hits_mean += res[i].hits / 1000000.0 / (0.0 + res_cnt);
+               important_hits_mean += res[i].important_hits / 1000000.0 / (0.0 + res_cnt);
+       }
+
+       if (res_cnt > 1)  {
+               for (i = 0; i < res_cnt; i++) {
+                       hits_stddev += (hits_mean - res[i].hits / 1000000.0) *
+                                      (hits_mean - res[i].hits / 1000000.0) /
+                                      (res_cnt - 1.0);
+                       important_hits_stddev +=
+                                      (important_hits_mean - res[i].important_hits / 1000000.0) *
+                                      (important_hits_mean - res[i].important_hits / 1000000.0) /
+                                      (res_cnt - 1.0);
+               }
+
+               hits_stddev = sqrt(hits_stddev);
+               important_hits_stddev = sqrt(important_hits_stddev);
+       }
+       printf("Summary: hits throughput %8.3lf \u00B1 %5.3lf M ops/s, ",
+              hits_mean, hits_stddev);
+       printf("hits latency %8.3lf ns/op, ", 1000.0 / hits_mean);
+       printf("important_hits throughput %8.3lf \u00B1 %5.3lf M ops/s\n",
+              important_hits_mean, important_hits_stddev);
+}
+
  const char *argp_program_version = "benchmark";
  const char *argp_program_bug_address = "<bpf@vger.kernel.org>";
  const char argp_program_doc[] =
@@ -188,12 +235,14 @@ static const struct argp_option opts[] = {
  extern struct argp bench_ringbufs_argp;
  extern struct argp bench_bloom_map_argp;
  extern struct argp bench_bpf_loop_argp;
+extern struct argp bench_local_storage_argp;
  extern struct argp bench_strncmp_argp;
  
  static const struct argp_child bench_parsers[] = {
         { &bench_ringbufs_argp, 0, "Ring buffers benchmark", 0 },
         { &bench_bloom_map_argp, 0, "Bloom filter map benchmark", 0 },
         { &bench_bpf_loop_argp, 0, "bpf_loop helper benchmark", 0 },
+       { &bench_local_storage_argp, 0, "local_storage benchmark", 0 },
         { &bench_strncmp_argp, 0, "bpf_strncmp helper benchmark", 0 },
         {},
  };
@@ -397,6 +446,9 @@ extern const struct bench bench_bpf_loop;
  extern const struct bench bench_strncmp_no_helper;
  extern const struct bench bench_strncmp_helper;
  extern const struct bench bench_bpf_hashmap_full_update;
+extern const struct bench bench_local_storage_cache_seq_get;
+extern const struct bench bench_local_storage_cache_interleaved_get;
+extern const struct bench bench_local_storage_cache_hashmap_control;
  
  static const struct bench *benchs[] = {
         &bench_count_global,
@@ -432,6 +484,9 @@ static const struct bench *benchs[] = {
         &bench_strncmp_no_helper,
         &bench_strncmp_helper,
         &bench_bpf_hashmap_full_update,
+       &bench_local_storage_cache_seq_get,
+       &bench_local_storage_cache_interleaved_get,
+       &bench_local_storage_cache_hashmap_control,
  };
  
  static void setup_benchmark()
diff --git a/tools/testing/selftests/bpf/bench.h b/tools/testing/selftests/bpf/bench.h

index fb3e213..4b15286 100644 (file)
--- a/tools/testing/selftests/bpf/bench.h
+++ b/tools/testing/selftests/bpf/bench.h
@@ -34,6 +34,7 @@ struct bench_res {
         long hits;
         long drops;
         long false_hits;
+       long important_hits;
  };
  
  struct bench {
@@ -61,6 +62,9 @@ void false_hits_report_progress(int iter, struct bench_res *res, long delta_ns);
  void false_hits_report_final(struct bench_res res[], int res_cnt);
  void ops_report_progress(int iter, struct bench_res *res, long delta_ns);
  void ops_report_final(struct bench_res res[], int res_cnt);
+void local_storage_report_progress(int iter, struct bench_res *res,
+                                  long delta_ns);
+void local_storage_report_final(struct bench_res res[], int res_cnt);
  
  static inline __u64 get_time_ns(void)
  {
diff --git a/tools/testing/selftests/bpf/benchs/bench_local_storage.c b/tools/testing/selftests/bpf/benchs/bench_local_storage.c

new file mode 100644 (file)

index 0000000..5a378c8
--- /dev/null
+++ b/tools/testing/selftests/bpf/benchs/bench_local_storage.c
@@ -0,0 +1,287 @@
+// SPDX-License-Identifier: GPL-2.0
+/* Copyright (c) 2022 Meta Platforms, Inc. and affiliates. */
+
+#include <argp.h>
+#include <linux/btf.h>
+
+#include "local_storage_bench.skel.h"
+#include "bench.h"
+
+#include <test_btf.h>
+
+static struct {
+       __u32 nr_maps;
+       __u32 hashmap_nr_keys_used;
+} args = {
+       .nr_maps = 1000,
+       .hashmap_nr_keys_used = 1000,
+};
+
+enum {
+       ARG_NR_MAPS = 6000,
+       ARG_HASHMAP_NR_KEYS_USED = 6001,
+};
+
+static const struct argp_option opts[] = {
+       { "nr_maps", ARG_NR_MAPS, "NR_MAPS", 0,
+               "Set number of local_storage maps"},
+       { "hashmap_nr_keys_used", ARG_HASHMAP_NR_KEYS_USED, "NR_KEYS",
+               0, "When doing hashmap test, set number of hashmap keys test uses"},
+       {},
+};
+
+static error_t parse_arg(int key, char *arg, struct argp_state *state)
+{
+       long ret;
+
+       switch (key) {
+       case ARG_NR_MAPS:
+               ret = strtol(arg, NULL, 10);
+               if (ret < 1 || ret > UINT_MAX) {
+                       fprintf(stderr, "invalid nr_maps");
+                       argp_usage(state);
+               }
+               args.nr_maps = ret;
+               break;
+       case ARG_HASHMAP_NR_KEYS_USED:
+               ret = strtol(arg, NULL, 10);
+               if (ret < 1 || ret > UINT_MAX) {
+                       fprintf(stderr, "invalid hashmap_nr_keys_used");
+                       argp_usage(state);
+               }
+               args.hashmap_nr_keys_used = ret;
+               break;
+       default:
+               return ARGP_ERR_UNKNOWN;
+       }
+
+       return 0;
+}
+
+const struct argp bench_local_storage_argp = {
+       .options = opts,
+       .parser = parse_arg,
+};
+
+/* Keep in sync w/ array of maps in bpf */
+#define MAX_NR_MAPS 1000
+/* keep in sync w/ same define in bpf */
+#define HASHMAP_SZ 4194304
+
+static void validate(void)
+{
+       if (env.producer_cnt != 1) {
+               fprintf(stderr, "benchmark doesn't support multi-producer!\n");
+               exit(1);
+       }
+       if (env.consumer_cnt != 1) {
+               fprintf(stderr, "benchmark doesn't support multi-consumer!\n");
+               exit(1);
+       }
+
+       if (args.nr_maps > MAX_NR_MAPS) {
+               fprintf(stderr, "nr_maps must be <= 1000\n");
+               exit(1);
+       }
+
+       if (args.hashmap_nr_keys_used > HASHMAP_SZ) {
+               fprintf(stderr, "hashmap_nr_keys_used must be <= %u\n", HASHMAP_SZ);
+               exit(1);
+       }
+}
+
+static struct {
+       struct local_storage_bench *skel;
+       void *bpf_obj;
+       struct bpf_map *array_of_maps;
+} ctx;
+
+static void prepopulate_hashmap(int fd)
+{
+       int i, key, val;
+
+       /* local_storage gets will have BPF_LOCAL_STORAGE_GET_F_CREATE flag set, so
+        * populate the hashmap for a similar comparison
+        */
+       for (i = 0; i < HASHMAP_SZ; i++) {
+               key = val = i;
+               if (bpf_map_update_elem(fd, &key, &val, 0)) {
+                       fprintf(stderr, "Error prepopulating hashmap (key %d)\n", key);
+                       exit(1);
+               }
+       }
+}
+
+static void __setup(struct bpf_program *prog, bool hashmap)
+{
+       struct bpf_map *inner_map;
+       int i, fd, mim_fd, err;
+
+       LIBBPF_OPTS(bpf_map_create_opts, create_opts);
+
+       if (!hashmap)
+               create_opts.map_flags = BPF_F_NO_PREALLOC;
+
+       ctx.skel->rodata->num_maps = args.nr_maps;
+       ctx.skel->rodata->hashmap_num_keys = args.hashmap_nr_keys_used;
+       inner_map = bpf_map__inner_map(ctx.array_of_maps);
+       create_opts.btf_key_type_id = bpf_map__btf_key_type_id(inner_map);
+       create_opts.btf_value_type_id = bpf_map__btf_value_type_id(inner_map);
+
+       err = local_storage_bench__load(ctx.skel);
+       if (err) {
+               fprintf(stderr, "Error loading skeleton\n");
+               goto err_out;
+       }
+
+       create_opts.btf_fd = bpf_object__btf_fd(ctx.skel->obj);
+
+       mim_fd = bpf_map__fd(ctx.array_of_maps);
+       if (mim_fd < 0) {
+               fprintf(stderr, "Error getting map_in_map fd\n");
+               goto err_out;
+       }
+
+       for (i = 0; i < args.nr_maps; i++) {
+               if (hashmap)
+                       fd = bpf_map_create(BPF_MAP_TYPE_HASH, NULL, sizeof(int),
+                                           sizeof(int), HASHMAP_SZ, &create_opts);
+               else
+                       fd = bpf_map_create(BPF_MAP_TYPE_TASK_STORAGE, NULL, sizeof(int),
+                                           sizeof(int), 0, &create_opts);
+               if (fd < 0) {
+                       fprintf(stderr, "Error creating map %d: %d\n", i, fd);
+                       goto err_out;
+               }
+
+               if (hashmap)
+                       prepopulate_hashmap(fd);
+
+               err = bpf_map_update_elem(mim_fd, &i, &fd, 0);
+               if (err) {
+                       fprintf(stderr, "Error updating array-of-maps w/ map %d\n", i);
+                       goto err_out;
+               }
+       }
+
+       if (!bpf_program__attach(prog)) {
+               fprintf(stderr, "Error attaching bpf program\n");
+               goto err_out;
+       }
+
+       return;
+err_out:
+       exit(1);
+}
+
+static void hashmap_setup(void)
+{
+       struct local_storage_bench *skel;
+
+       setup_libbpf();
+
+       skel = local_storage_bench__open();
+       ctx.skel = skel;
+       ctx.array_of_maps = skel->maps.array_of_hash_maps;
+       skel->rodata->use_hashmap = 1;
+       skel->rodata->interleave = 0;
+
+       __setup(skel->progs.get_local, true);
+}
+
+static void local_storage_cache_get_setup(void)
+{
+       struct local_storage_bench *skel;
+
+       setup_libbpf();
+
+       skel = local_storage_bench__open();
+       ctx.skel = skel;
+       ctx.array_of_maps = skel->maps.array_of_local_storage_maps;
+       skel->rodata->use_hashmap = 0;
+       skel->rodata->interleave = 0;
+
+       __setup(skel->progs.get_local, false);
+}
+
+static void local_storage_cache_get_interleaved_setup(void)
+{
+       struct local_storage_bench *skel;
+
+       setup_libbpf();
+
+       skel = local_storage_bench__open();
+       ctx.skel = skel;
+       ctx.array_of_maps = skel->maps.array_of_local_storage_maps;
+       skel->rodata->use_hashmap = 0;
+       skel->rodata->interleave = 1;
+
+       __setup(skel->progs.get_local, false);
+}
+
+static void measure(struct bench_res *res)
+{
+       res->hits = atomic_swap(&ctx.skel->bss->hits, 0);
+       res->important_hits = atomic_swap(&ctx.skel->bss->important_hits, 0);
+}
+
+static inline void trigger_bpf_program(void)
+{
+       syscall(__NR_getpgid);
+}
+
+static void *consumer(void *input)
+{
+       return NULL;
+}
+
+static void *producer(void *input)
+{
+       while (true)
+               trigger_bpf_program();
+
+       return NULL;
+}
+
+/* cache sequential and interleaved get benchs test local_storage get
+ * performance, specifically they demonstrate performance cliff of
+ * current list-plus-cache local_storage model.
+ *
+ * cache sequential get: call bpf_task_storage_get on n maps in order
+ * cache interleaved get: like "sequential get", but interleave 4 calls to the
+ *     'important' map (idx 0 in array_of_maps) for every 10 calls. Goal
+ *     is to mimic environment where many progs are accessing their local_storage
+ *     maps, with 'our' prog needing to access its map more often than others
+ */
+const struct bench bench_local_storage_cache_seq_get = {
+       .name = "local-storage-cache-seq-get",
+       .validate = validate,
+       .setup = local_storage_cache_get_setup,
+       .producer_thread = producer,
+       .consumer_thread = consumer,
+       .measure = measure,
+       .report_progress = local_storage_report_progress,
+       .report_final = local_storage_report_final,
+};
+
+const struct bench bench_local_storage_cache_interleaved_get = {
+       .name = "local-storage-cache-int-get",
+       .validate = validate,
+       .setup = local_storage_cache_get_interleaved_setup,
+       .producer_thread = producer,
+       .consumer_thread = consumer,
+       .measure = measure,
+       .report_progress = local_storage_report_progress,
+       .report_final = local_storage_report_final,
+};
+
+const struct bench bench_local_storage_cache_hashmap_control = {
+       .name = "local-storage-cache-hashmap-control",
+       .validate = validate,
+       .setup = hashmap_setup,
+       .producer_thread = producer,
+       .consumer_thread = consumer,
+       .measure = measure,
+       .report_progress = local_storage_report_progress,
+       .report_final = local_storage_report_final,
+};
diff --git a/tools/testing/selftests/bpf/benchs/run_bench_local_storage.sh b/tools/testing/selftests/bpf/benchs/run_bench_local_storage.sh

new file mode 100755 (executable)

index 0000000..2eb2b51
--- /dev/null
+++ b/tools/testing/selftests/bpf/benchs/run_bench_local_storage.sh
@@ -0,0 +1,24 @@
+#!/bin/bash
+# SPDX-License-Identifier: GPL-2.0
+
+source ./benchs/run_common.sh
+
+set -eufo pipefail
+
+header "Hashmap Control"
+for i in 10 1000 10000 100000 4194304; do
+subtitle "num keys: $i"
+       summarize_local_storage "hashmap (control) sequential    get: "\
+               "$(./bench --nr_maps 1 --hashmap_nr_keys_used=$i local-storage-cache-hashmap-control)"
+       printf "\n"
+done
+
+header "Local Storage"
+for i in 1 10 16 17 24 32 100 1000; do
+subtitle "num_maps: $i"
+       summarize_local_storage "local_storage cache sequential  get: "\
+               "$(./bench --nr_maps $i local-storage-cache-seq-get)"
+       summarize_local_storage "local_storage cache interleaved get: "\
+               "$(./bench --nr_maps $i local-storage-cache-int-get)"
+       printf "\n"
+done
diff --git a/tools/testing/selftests/bpf/benchs/run_common.sh b/tools/testing/selftests/bpf/benchs/run_common.sh

index 6c5e602..d9f40af 100644 (file)
--- a/tools/testing/selftests/bpf/benchs/run_common.sh
+++ b/tools/testing/selftests/bpf/benchs/run_common.sh
@@ -41,6 +41,16 @@ function ops()
         echo "$*" | sed -E "s/.*latency\s+([0-9]+\.[0-9]+\sns\/op).*/\1/"
  }
  
+function local_storage()
+{
+       echo -n "hits throughput: "
+       echo -n "$*" | sed -E "s/.* hits throughput\s+([0-9]+\.[0-9]+ ± [0-9]+\.[0-9]+\sM\sops\/s).*/\1/"
+       echo -n -e ", hits latency: "
+       echo -n "$*" | sed -E "s/.* hits latency\s+([0-9]+\.[0-9]+\sns\/op).*/\1/"
+       echo -n ", important_hits throughput: "
+       echo "$*" | sed -E "s/.*important_hits throughput\s+([0-9]+\.[0-9]+ ± [0-9]+\.[0-9]+\sM\sops\/s).*/\1/"
+}
+
  function total()
  {
         echo "$*" | sed -E "s/.*total operations\s+([0-9]+\.[0-9]+ ± [0-9]+\.[0-9]+M\/s).*/\1/"
@@ -67,6 +77,13 @@ function summarize_ops()
         printf "%-20s %s\n" "$bench" "$(ops $summary)"
  }
  
+function summarize_local_storage()
+{
+       bench="$1"
+       summary=$(echo $2 | tail -n1)
+       printf "%-20s %s\n" "$bench" "$(local_storage $summary)"
+}
+
  function summarize_total()
  {
         bench="$1"
diff --git a/tools/testing/selftests/bpf/progs/local_storage_bench.c b/tools/testing/selftests/bpf/progs/local_storage_bench.c

new file mode 100644 (file)

index 0000000..2c3234c
--- /dev/null
+++ b/tools/testing/selftests/bpf/progs/local_storage_bench.c
@@ -0,0 +1,104 @@
+// SPDX-License-Identifier: GPL-2.0
+/* Copyright (c) 2022 Meta Platforms, Inc. and affiliates. */
+
+#include "vmlinux.h"
+#include <bpf/bpf_helpers.h>
+#include "bpf_misc.h"
+
+#define HASHMAP_SZ 4194304
+
+struct {
+       __uint(type, BPF_MAP_TYPE_ARRAY_OF_MAPS);
+       __uint(max_entries, 1000);
+       __type(key, int);
+       __type(value, int);
+       __array(values, struct {
+               __uint(type, BPF_MAP_TYPE_TASK_STORAGE);
+               __uint(map_flags, BPF_F_NO_PREALLOC);
+               __type(key, int);
+               __type(value, int);
+       });
+} array_of_local_storage_maps SEC(".maps");
+
+struct {
+       __uint(type, BPF_MAP_TYPE_ARRAY_OF_MAPS);
+       __uint(max_entries, 1000);
+       __type(key, int);
+       __type(value, int);
+       __array(values, struct {
+               __uint(type, BPF_MAP_TYPE_HASH);
+               __uint(max_entries, HASHMAP_SZ);
+               __type(key, int);
+               __type(value, int);
+       });
+} array_of_hash_maps SEC(".maps");
+
+long important_hits;
+long hits;
+
+/* set from user-space */
+const volatile unsigned int use_hashmap;
+const volatile unsigned int hashmap_num_keys;
+const volatile unsigned int num_maps;
+const volatile unsigned int interleave;
+
+struct loop_ctx {
+       struct task_struct *task;
+       long loop_hits;
+       long loop_important_hits;
+};
+
+static int do_lookup(unsigned int elem, struct loop_ctx *lctx)
+{
+       void *map, *inner_map;
+       int idx = 0;
+
+       if (use_hashmap)
+               map = &array_of_hash_maps;
+       else
+               map = &array_of_local_storage_maps;
+
+       inner_map = bpf_map_lookup_elem(map, &elem);
+       if (!inner_map)
+               return -1;
+
+       if (use_hashmap) {
+               idx = bpf_get_prandom_u32() % hashmap_num_keys;
+               bpf_map_lookup_elem(inner_map, &idx);
+       } else {
+               bpf_task_storage_get(inner_map, lctx->task, &idx,
+                                    BPF_LOCAL_STORAGE_GET_F_CREATE);
+       }
+
+       lctx->loop_hits++;
+       if (!elem)
+               lctx->loop_important_hits++;
+       return 0;
+}
+
+static long loop(u32 index, void *ctx)
+{
+       struct loop_ctx *lctx = (struct loop_ctx *)ctx;
+       unsigned int map_idx = index % num_maps;
+
+       do_lookup(map_idx, lctx);
+       if (interleave && map_idx % 3 == 0)
+               do_lookup(0, lctx);
+       return 0;
+}
+
+SEC("fentry/" SYS_PREFIX "sys_getpgid")
+int get_local(void *ctx)
+{
+       struct loop_ctx lctx;
+
+       lctx.task = bpf_get_current_task_btf();
+       lctx.loop_hits = 0;
+       lctx.loop_important_hits = 0;
+       bpf_loop(10000, &loop, &lctx, 0);
+       __sync_add_and_fetch(&hits, lctx.loop_hits);
+       __sync_add_and_fetch(&important_hits, lctx.loop_important_hits);
+       return 0;
+}
+
+char _license[] SEC("license") = "GPL";
author	Dave Marchevsky <davemarchevsky@fb.com>
	Mon, 20 Jun 2022 22:25:54 +0000 (15:25 -0700)
committer	Alexei Starovoitov <ast@kernel.org>
	Thu, 23 Jun 2022 02:14:33 +0000 (19:14 -0700)
tools/testing/selftests/bpf/Makefile		patch \| blob \| history
tools/testing/selftests/bpf/bench.c		patch \| blob \| history
tools/testing/selftests/bpf/bench.h		patch \| blob \| history
tools/testing/selftests/bpf/benchs/bench_local_storage.c	[new file with mode: 0644]	patch \| blob
tools/testing/selftests/bpf/benchs/run_bench_local_storage.sh	[new file with mode: 0755]	patch \| blob
tools/testing/selftests/bpf/benchs/run_common.sh		patch \| blob \| history
tools/testing/selftests/bpf/progs/local_storage_bench.c	[new file with mode: 0644]	patch \| blob