| Message ID | 20210412194001.946213-4-pctammela@mojatatu.com (mailing list archive) |
|---|---|
| State | Superseded |
| Delegated to: | BPF |
| Headers | show |
| Series | add batched ops for percpu array | expand |
| Context | Check | Description |
|---|---|---|
| netdev/cover_letter | success | Link |
| netdev/fixes_present | success | Link |
| netdev/patch_count | success | Link |
| netdev/tree_selection | success | Clearly marked for bpf-next |
| netdev/subject_prefix | success | Link |
| netdev/cc_maintainers | success | CCed 13 of 13 maintainers |
| netdev/source_inline | success | Was 0 now: 0 |
| netdev/verify_signedoff | success | Link |
| netdev/module_param | success | Was 0 now: 0 |
| netdev/build_32bit | success | Errors and warnings before: 0 this patch: 0 |
| netdev/kdoc | success | Errors and warnings before: 0 this patch: 0 |
| netdev/verify_fixes | success | Link |
| netdev/checkpatch | warning | WARNING: From:/Signed-off-by: email address mismatch: 'From: Pedro Tammela <pctammela@gmail.com>' != 'Signed-off-by: Pedro Tammela <pctammela@mojatatu.com>' WARNING: Missing a blank line after declarations |
| netdev/build_allmodconfig_warn | success | Errors and warnings before: 0 this patch: 0 |
| netdev/header_inline | success | Link |
On Mon, Apr 12, 2021 at 04:40:01PM -0300, Pedro Tammela wrote: > Follows the same logic as the hashtable tests. > > Signed-off-by: Pedro Tammela <pctammela@mojatatu.com> > --- > .../bpf/map_tests/array_map_batch_ops.c | 110 +++++++++++++----- > 1 file changed, 80 insertions(+), 30 deletions(-) > > diff --git a/tools/testing/selftests/bpf/map_tests/array_map_batch_ops.c b/tools/testing/selftests/bpf/map_tests/array_map_batch_ops.c > index e42ea1195d18..707d17414dee 100644 > --- a/tools/testing/selftests/bpf/map_tests/array_map_batch_ops.c > +++ b/tools/testing/selftests/bpf/map_tests/array_map_batch_ops.c > @@ -10,32 +10,59 @@ > #include <test_maps.h> > > static void map_batch_update(int map_fd, __u32 max_entries, int *keys, > - int *values) > + __s64 *values, bool is_pcpu) > { > - int i, err; > + int nr_cpus = libbpf_num_possible_cpus(); Instead of getting it multiple times, how about moving it out to a static global and initialize it in test_array_map_batch_ops(). > + int i, j, err; > + int offset = 0; > DECLARE_LIBBPF_OPTS(bpf_map_batch_opts, opts, > .elem_flags = 0, > .flags = 0, > ); > > + CHECK(nr_cpus < 0, "nr_cpus checking", > + "error: get possible cpus failed"); > + > for (i = 0; i < max_entries; i++) { > keys[i] = i; > - values[i] = i + 1; > + if (is_pcpu) > + for (j = 0; j < nr_cpus; j++) > + (values + offset)[j] = i + 1 + j; > + else > + values[i] = i + 1; > + offset += nr_cpus; This "offset" update here is confusing to read because it is only used in the is_pcpu case but it always gets updated regardless. How about only defines and uses offset in the "if (is_pcpu)" case and rename it to "cpu_offset": cpu_offset = i * nr_cpus. The same goes for other occasions. > } > > err = bpf_map_update_batch(map_fd, keys, values, &max_entries, &opts); > CHECK(err, "bpf_map_update_batch()", "error:%s\n", strerror(errno)); > } > > -static void map_batch_verify(int *visited, __u32 max_entries, > - int *keys, int *values) > +static void map_batch_verify(int *visited, __u32 max_entries, int *keys, > + __s64 *values, bool is_pcpu) > { > - int i; > + int nr_cpus = libbpf_num_possible_cpus(); > + int i, j; > + int offset = 0; > + > + CHECK(nr_cpus < 0, "nr_cpus checking", > + "error: get possible cpus failed"); > > memset(visited, 0, max_entries * sizeof(*visited)); > for (i = 0; i < max_entries; i++) { > - CHECK(keys[i] + 1 != values[i], "key/value checking", > - "error: i %d key %d value %d\n", i, keys[i], values[i]); > + if (is_pcpu) { > + for (j = 0; j < nr_cpus; j++) { > + __s64 value = (values + offset)[j]; > + CHECK(keys[i] + j + 1 != value, > + "key/value checking", > + "error: i %d j %d key %d value %d\n", i, > + j, keys[i], value); > + } > + } else { > + CHECK(keys[i] + 1 != values[i], "key/value checking", > + "error: i %d key %d value %d\n", i, keys[i], > + values[i]); > + } > + offset += nr_cpus; > visited[i] = 1; > } > for (i = 0; i < max_entries; i++) { > @@ -44,45 +71,52 @@ static void map_batch_verify(int *visited, __u32 max_entries, > } > } > > -void test_array_map_batch_ops(void) > +void __test_map_lookup_and_update_batch(bool is_pcpu) static > { > + int nr_cpus = libbpf_num_possible_cpus(); > struct bpf_create_map_attr xattr = { > .name = "array_map", > - .map_type = BPF_MAP_TYPE_ARRAY, > + .map_type = is_pcpu ? BPF_MAP_TYPE_PERCPU_ARRAY : > + BPF_MAP_TYPE_ARRAY, > .key_size = sizeof(int), > - .value_size = sizeof(int), > + .value_size = sizeof(__s64), > }; > - int map_fd, *keys, *values, *visited; > + int map_fd, *keys, *visited; > __u32 count, total, total_success; > const __u32 max_entries = 10; > __u64 batch = 0; > - int err, step; > + int err, step, value_size; > + void *values; > DECLARE_LIBBPF_OPTS(bpf_map_batch_opts, opts, > .elem_flags = 0, > .flags = 0, > ); > > + CHECK(nr_cpus < 0, "nr_cpus checking", > + "error: get possible cpus failed"); > + > xattr.max_entries = max_entries; > map_fd = bpf_create_map_xattr(&xattr); > CHECK(map_fd == -1, > "bpf_create_map_xattr()", "error:%s\n", strerror(errno)); > > - keys = malloc(max_entries * sizeof(int)); > - values = malloc(max_entries * sizeof(int)); > - visited = malloc(max_entries * sizeof(int)); > + value_size = sizeof(__s64); > + if (is_pcpu) > + value_size *= nr_cpus; > + > + keys = malloc(max_entries * sizeof(*keys)); > + values = calloc(max_entries, value_size); Why only this one uses calloc? > + visited = malloc(max_entries * sizeof(*visited)); > CHECK(!keys || !values || !visited, "malloc()", "error:%s\n", > strerror(errno)); > > - /* populate elements to the map */ > - map_batch_update(map_fd, max_entries, keys, values); > - > /* test 1: lookup in a loop with various steps. */ > total_success = 0; > for (step = 1; step < max_entries; step++) { > - map_batch_update(map_fd, max_entries, keys, values); > - map_batch_verify(visited, max_entries, keys, values); > + map_batch_update(map_fd, max_entries, keys, values, is_pcpu); > + map_batch_verify(visited, max_entries, keys, values, is_pcpu); > memset(keys, 0, max_entries * sizeof(*keys)); > - memset(values, 0, max_entries * sizeof(*values)); > + memset(values, 0, max_entries * value_size); > batch = 0; > total = 0; > /* iteratively lookup/delete elements with 'step' > @@ -91,10 +125,10 @@ void test_array_map_batch_ops(void) > count = step; > while (true) { > err = bpf_map_lookup_batch(map_fd, > - total ? &batch : NULL, &batch, > - keys + total, > - values + total, > - &count, &opts); > + total ? &batch : NULL, > + &batch, keys + total, > + values + total * value_size, > + &count, &opts); > > CHECK((err && errno != ENOENT), "lookup with steps", > "error: %s\n", strerror(errno)); > @@ -108,7 +142,7 @@ void test_array_map_batch_ops(void) > CHECK(total != max_entries, "lookup with steps", > "total = %u, max_entries = %u\n", total, max_entries); > > - map_batch_verify(visited, max_entries, keys, values); > + map_batch_verify(visited, max_entries, keys, values, is_pcpu); > > total_success++; > } > @@ -116,9 +150,25 @@ void test_array_map_batch_ops(void) > CHECK(total_success == 0, "check total_success", > "unexpected failure\n"); > > - printf("%s:PASS\n", __func__); > - > free(keys); > - free(values); > free(visited); > + free(values); This re-ordering is unnecessary. > +} > + > +void array_map_batch_ops(void) static > +{ > + __test_map_lookup_and_update_batch(false); > + printf("test_%s:PASS\n", __func__); > +} > + > +void array_percpu_map_batch_ops(void) static > +{ > + __test_map_lookup_and_update_batch(true); > + printf("test_%s:PASS\n", __func__); > +} > + > +void test_array_map_batch_ops(void) > +{ > + array_map_batch_ops(); > + array_percpu_map_batch_ops(); > } > -- > 2.25.1 >
diff --git a/tools/testing/selftests/bpf/map_tests/array_map_batch_ops.c b/tools/testing/selftests/bpf/map_tests/array_map_batch_ops.c index e42ea1195d18..707d17414dee 100644 --- a/tools/testing/selftests/bpf/map_tests/array_map_batch_ops.c +++ b/tools/testing/selftests/bpf/map_tests/array_map_batch_ops.c @@ -10,32 +10,59 @@ #include <test_maps.h> static void map_batch_update(int map_fd, __u32 max_entries, int *keys, - int *values) + __s64 *values, bool is_pcpu) { - int i, err; + int nr_cpus = libbpf_num_possible_cpus(); + int i, j, err; + int offset = 0; DECLARE_LIBBPF_OPTS(bpf_map_batch_opts, opts, .elem_flags = 0, .flags = 0, ); + CHECK(nr_cpus < 0, "nr_cpus checking", + "error: get possible cpus failed"); + for (i = 0; i < max_entries; i++) { keys[i] = i; - values[i] = i + 1; + if (is_pcpu) + for (j = 0; j < nr_cpus; j++) + (values + offset)[j] = i + 1 + j; + else + values[i] = i + 1; + offset += nr_cpus; } err = bpf_map_update_batch(map_fd, keys, values, &max_entries, &opts); CHECK(err, "bpf_map_update_batch()", "error:%s\n", strerror(errno)); } -static void map_batch_verify(int *visited, __u32 max_entries, - int *keys, int *values) +static void map_batch_verify(int *visited, __u32 max_entries, int *keys, + __s64 *values, bool is_pcpu) { - int i; + int nr_cpus = libbpf_num_possible_cpus(); + int i, j; + int offset = 0; + + CHECK(nr_cpus < 0, "nr_cpus checking", + "error: get possible cpus failed"); memset(visited, 0, max_entries * sizeof(*visited)); for (i = 0; i < max_entries; i++) { - CHECK(keys[i] + 1 != values[i], "key/value checking", - "error: i %d key %d value %d\n", i, keys[i], values[i]); + if (is_pcpu) { + for (j = 0; j < nr_cpus; j++) { + __s64 value = (values + offset)[j]; + CHECK(keys[i] + j + 1 != value, + "key/value checking", + "error: i %d j %d key %d value %d\n", i, + j, keys[i], value); + } + } else { + CHECK(keys[i] + 1 != values[i], "key/value checking", + "error: i %d key %d value %d\n", i, keys[i], + values[i]); + } + offset += nr_cpus; visited[i] = 1; } for (i = 0; i < max_entries; i++) { @@ -44,45 +71,52 @@ static void map_batch_verify(int *visited, __u32 max_entries, } } -void test_array_map_batch_ops(void) +void __test_map_lookup_and_update_batch(bool is_pcpu) { + int nr_cpus = libbpf_num_possible_cpus(); struct bpf_create_map_attr xattr = { .name = "array_map", - .map_type = BPF_MAP_TYPE_ARRAY, + .map_type = is_pcpu ? BPF_MAP_TYPE_PERCPU_ARRAY : + BPF_MAP_TYPE_ARRAY, .key_size = sizeof(int), - .value_size = sizeof(int), + .value_size = sizeof(__s64), }; - int map_fd, *keys, *values, *visited; + int map_fd, *keys, *visited; __u32 count, total, total_success; const __u32 max_entries = 10; __u64 batch = 0; - int err, step; + int err, step, value_size; + void *values; DECLARE_LIBBPF_OPTS(bpf_map_batch_opts, opts, .elem_flags = 0, .flags = 0, ); + CHECK(nr_cpus < 0, "nr_cpus checking", + "error: get possible cpus failed"); + xattr.max_entries = max_entries; map_fd = bpf_create_map_xattr(&xattr); CHECK(map_fd == -1, "bpf_create_map_xattr()", "error:%s\n", strerror(errno)); - keys = malloc(max_entries * sizeof(int)); - values = malloc(max_entries * sizeof(int)); - visited = malloc(max_entries * sizeof(int)); + value_size = sizeof(__s64); + if (is_pcpu) + value_size *= nr_cpus; + + keys = malloc(max_entries * sizeof(*keys)); + values = calloc(max_entries, value_size); + visited = malloc(max_entries * sizeof(*visited)); CHECK(!keys || !values || !visited, "malloc()", "error:%s\n", strerror(errno)); - /* populate elements to the map */ - map_batch_update(map_fd, max_entries, keys, values); - /* test 1: lookup in a loop with various steps. */ total_success = 0; for (step = 1; step < max_entries; step++) { - map_batch_update(map_fd, max_entries, keys, values); - map_batch_verify(visited, max_entries, keys, values); + map_batch_update(map_fd, max_entries, keys, values, is_pcpu); + map_batch_verify(visited, max_entries, keys, values, is_pcpu); memset(keys, 0, max_entries * sizeof(*keys)); - memset(values, 0, max_entries * sizeof(*values)); + memset(values, 0, max_entries * value_size); batch = 0; total = 0; /* iteratively lookup/delete elements with 'step' @@ -91,10 +125,10 @@ void test_array_map_batch_ops(void) count = step; while (true) { err = bpf_map_lookup_batch(map_fd, - total ? &batch : NULL, &batch, - keys + total, - values + total, - &count, &opts); + total ? &batch : NULL, + &batch, keys + total, + values + total * value_size, + &count, &opts); CHECK((err && errno != ENOENT), "lookup with steps", "error: %s\n", strerror(errno)); @@ -108,7 +142,7 @@ void test_array_map_batch_ops(void) CHECK(total != max_entries, "lookup with steps", "total = %u, max_entries = %u\n", total, max_entries); - map_batch_verify(visited, max_entries, keys, values); + map_batch_verify(visited, max_entries, keys, values, is_pcpu); total_success++; } @@ -116,9 +150,25 @@ void test_array_map_batch_ops(void) CHECK(total_success == 0, "check total_success", "unexpected failure\n"); - printf("%s:PASS\n", __func__); - free(keys); - free(values); free(visited); + free(values); +} + +void array_map_batch_ops(void) +{ + __test_map_lookup_and_update_batch(false); + printf("test_%s:PASS\n", __func__); +} + +void array_percpu_map_batch_ops(void) +{ + __test_map_lookup_and_update_batch(true); + printf("test_%s:PASS\n", __func__); +} + +void test_array_map_batch_ops(void) +{ + array_map_batch_ops(); + array_percpu_map_batch_ops(); }
Follows the same logic as the hashtable tests. Signed-off-by: Pedro Tammela <pctammela@mojatatu.com> --- .../bpf/map_tests/array_map_batch_ops.c | 110 +++++++++++++----- 1 file changed, 80 insertions(+), 30 deletions(-)