From: David Carlier <devnexen@gmail.com>
To: Josh Law <objecting@objecting.org>, Dennis Zhou <dennis@kernel.org>
Cc: Mathieu Desnoyers <mathieu.desnoyers@efficios.com>,
Andrew Morton <akpm@linux-foundation.org>,
linux-kernel@vger.kernel.org, David Carlier <devnexen@gmail.com>
Subject: [PATCH 2/2] lib: add kunit boundary tests for percpu_counter_tree comparisons
Date: Mon, 16 Mar 2026 14:38:05 +0000 [thread overview]
Message-ID: <20260316143805.36805-2-devnexen@gmail.com> (raw)
In-Reply-To: <20260316143805.36805-1-devnexen@gmail.com>
Add boundary tests for all four comparison APIs to validate that
the accuracy parameters are correctly applied:
- percpu_counter_tree_approximate_compare_value()
- percpu_counter_tree_precise_compare_value()
- percpu_counter_tree_approximate_compare()
- percpu_counter_tree_precise_compare()
The single-value tests probe the accuracy range boundaries (at,
beyond, and in the asymmetric gap between under and over) to catch
swapped accuracy parameters. The two-counter tests verify the
symmetric combined accuracy boundary for counter-to-counter
comparisons.
Signed-off-by: David Carlier <devnexen@gmail.com>
---
lib/tests/percpu_counter_tree_kunit.c | 190 ++++++++++++++++++++++++++
1 file changed, 190 insertions(+)
diff --git a/lib/tests/percpu_counter_tree_kunit.c b/lib/tests/percpu_counter_tree_kunit.c
index a79176655c4b..4d058bc78f7d 100644
--- a/lib/tests/percpu_counter_tree_kunit.c
+++ b/lib/tests/percpu_counter_tree_kunit.c
@@ -86,6 +86,194 @@ static void check_counters(struct kunit *test)
KUNIT_EXPECT_EQ(test, 0, percpu_counter_tree_approximate_compare(&counter[0], &counter[1]));
}
+static void hpcc_test_compare_value_boundaries(struct kunit *test)
+{
+ struct percpu_counter_tree pct;
+ struct percpu_counter_tree_level_item *counter_items;
+ unsigned long under = 0, over = 0;
+ int ret;
+
+ counter_items = kzalloc(percpu_counter_tree_items_size(), GFP_KERNEL);
+ KUNIT_ASSERT_PTR_NE(test, counter_items, NULL);
+ ret = percpu_counter_tree_init(&pct, counter_items, 32, GFP_KERNEL);
+ KUNIT_ASSERT_EQ(test, ret, 0);
+
+ percpu_counter_tree_set(&pct, 0);
+ percpu_counter_tree_approximate_accuracy_range(&pct, &under, &over);
+
+ /*
+ * With approx_sum = precise_sum = 0, from the accuracy invariant:
+ * approx_sum - over <= precise_sum <= approx_sum + under
+ * Positive deltas use 'under' as tolerance, negative use 'over'.
+ */
+
+ /* --- percpu_counter_tree_approximate_compare_value --- */
+
+ /* At boundary: indeterminate */
+ KUNIT_EXPECT_EQ(test, 0,
+ percpu_counter_tree_approximate_compare_value(&pct,
+ (long)under));
+ KUNIT_EXPECT_EQ(test, 0,
+ percpu_counter_tree_approximate_compare_value(&pct,
+ -(long)over));
+
+ /* Beyond boundary: definitive */
+ KUNIT_EXPECT_EQ(test, 1,
+ percpu_counter_tree_approximate_compare_value(&pct,
+ (long)(under + 1)));
+ KUNIT_EXPECT_EQ(test, -1,
+ percpu_counter_tree_approximate_compare_value(&pct,
+ -(long)(over + 1)));
+
+ /* Asymmetric gap: catches swapped accuracy parameters */
+ if (under != over) {
+ if (under > over) {
+ KUNIT_EXPECT_EQ(test, 0,
+ percpu_counter_tree_approximate_compare_value(
+ &pct, (long)(over + 1)));
+ KUNIT_EXPECT_EQ(test, -1,
+ percpu_counter_tree_approximate_compare_value(
+ &pct, -(long)(over + 1)));
+ } else {
+ KUNIT_EXPECT_EQ(test, 1,
+ percpu_counter_tree_approximate_compare_value(
+ &pct, (long)(under + 1)));
+ KUNIT_EXPECT_EQ(test, 0,
+ percpu_counter_tree_approximate_compare_value(
+ &pct, -(long)(under + 1)));
+ }
+ }
+
+ /* --- percpu_counter_tree_precise_compare_value --- */
+
+ /*
+ * With approx_sum = precise_sum = 0, the precise comparison
+ * must return the exact result. At boundary values the
+ * approximate fast-path returns indeterminate, exercising
+ * the precise sum fallback.
+ */
+ KUNIT_EXPECT_EQ(test, 0,
+ percpu_counter_tree_precise_compare_value(&pct, 0));
+ KUNIT_EXPECT_EQ(test, 1,
+ percpu_counter_tree_precise_compare_value(&pct,
+ (long)under));
+ KUNIT_EXPECT_EQ(test, -1,
+ percpu_counter_tree_precise_compare_value(&pct,
+ -(long)over));
+ KUNIT_EXPECT_EQ(test, 1,
+ percpu_counter_tree_precise_compare_value(&pct,
+ (long)(under + 1)));
+ KUNIT_EXPECT_EQ(test, -1,
+ percpu_counter_tree_precise_compare_value(&pct,
+ -(long)(over + 1)));
+
+ if (under != over) {
+ if (under > over) {
+ KUNIT_EXPECT_EQ(test, 1,
+ percpu_counter_tree_precise_compare_value(
+ &pct, (long)(over + 1)));
+ KUNIT_EXPECT_EQ(test, -1,
+ percpu_counter_tree_precise_compare_value(
+ &pct, -(long)(over + 1)));
+ } else {
+ KUNIT_EXPECT_EQ(test, 1,
+ percpu_counter_tree_precise_compare_value(
+ &pct, (long)(under + 1)));
+ KUNIT_EXPECT_EQ(test, -1,
+ percpu_counter_tree_precise_compare_value(
+ &pct, -(long)(under + 1)));
+ }
+ }
+
+ percpu_counter_tree_destroy(&pct);
+ kfree(counter_items);
+}
+
+static void hpcc_test_compare_counter_boundaries(struct kunit *test)
+{
+ struct percpu_counter_tree pct[2];
+ struct percpu_counter_tree_level_item *counter_items;
+ unsigned long under = 0, over = 0;
+ unsigned long combined;
+ int ret;
+
+ counter_items = kzalloc(percpu_counter_tree_items_size() * 2,
+ GFP_KERNEL);
+ KUNIT_ASSERT_PTR_NE(test, counter_items, NULL);
+ ret = percpu_counter_tree_init_many(pct, counter_items, 2, 32,
+ GFP_KERNEL);
+ KUNIT_ASSERT_EQ(test, ret, 0);
+
+ percpu_counter_tree_approximate_accuracy_range(&pct[0],
+ &under, &over);
+
+ /*
+ * Both counters have the same configuration. The combined
+ * accuracy for two-counter comparison is symmetric:
+ * accuracy_pos = over + under = under + over = accuracy_neg
+ */
+ combined = under + over;
+
+ /* --- percpu_counter_tree_approximate_compare --- */
+
+ /* At boundary: indeterminate */
+ percpu_counter_tree_set(&pct[0], (long)combined);
+ percpu_counter_tree_set(&pct[1], 0);
+ KUNIT_EXPECT_EQ(test, 0,
+ percpu_counter_tree_approximate_compare(&pct[0], &pct[1]));
+
+ percpu_counter_tree_set(&pct[0], 0);
+ percpu_counter_tree_set(&pct[1], (long)combined);
+ KUNIT_EXPECT_EQ(test, 0,
+ percpu_counter_tree_approximate_compare(&pct[0], &pct[1]));
+
+ /* Beyond boundary: definitive */
+ percpu_counter_tree_set(&pct[0], (long)(combined + 1));
+ percpu_counter_tree_set(&pct[1], 0);
+ KUNIT_EXPECT_EQ(test, 1,
+ percpu_counter_tree_approximate_compare(&pct[0], &pct[1]));
+
+ percpu_counter_tree_set(&pct[0], 0);
+ percpu_counter_tree_set(&pct[1], (long)(combined + 1));
+ KUNIT_EXPECT_EQ(test, -1,
+ percpu_counter_tree_approximate_compare(&pct[0], &pct[1]));
+
+ /* --- percpu_counter_tree_precise_compare --- */
+
+ /* At boundary: precise gives exact result */
+ percpu_counter_tree_set(&pct[0], (long)combined);
+ percpu_counter_tree_set(&pct[1], 0);
+ KUNIT_EXPECT_EQ(test, 1,
+ percpu_counter_tree_precise_compare(&pct[0], &pct[1]));
+
+ percpu_counter_tree_set(&pct[0], 0);
+ percpu_counter_tree_set(&pct[1], (long)combined);
+ KUNIT_EXPECT_EQ(test, -1,
+ percpu_counter_tree_precise_compare(&pct[0], &pct[1]));
+
+ /* Beyond boundary: definitive */
+ percpu_counter_tree_set(&pct[0], (long)(combined + 1));
+ percpu_counter_tree_set(&pct[1], 0);
+ KUNIT_EXPECT_EQ(test, 1,
+ percpu_counter_tree_precise_compare(&pct[0], &pct[1]));
+
+ percpu_counter_tree_set(&pct[0], 0);
+ percpu_counter_tree_set(&pct[1], (long)(combined + 1));
+ KUNIT_EXPECT_EQ(test, -1,
+ percpu_counter_tree_precise_compare(&pct[0], &pct[1]));
+
+ /* Equal counters */
+ percpu_counter_tree_set(&pct[0], 42);
+ percpu_counter_tree_set(&pct[1], 42);
+ KUNIT_EXPECT_EQ(test, 0,
+ percpu_counter_tree_approximate_compare(&pct[0], &pct[1]));
+ KUNIT_EXPECT_EQ(test, 0,
+ percpu_counter_tree_precise_compare(&pct[0], &pct[1]));
+
+ percpu_counter_tree_destroy_many(pct, 2);
+ kfree(counter_items);
+}
+
static int multi_thread_worker_fn(void *data)
{
struct multi_thread_test_data *td = data;
@@ -383,6 +571,8 @@ static struct kunit_case hpcc_test_cases[] = {
KUNIT_CASE(hpcc_test_single_thread_random),
KUNIT_CASE(hpcc_test_multi_thread_batch_increment),
KUNIT_CASE(hpcc_test_multi_thread_random_walk),
+ KUNIT_CASE(hpcc_test_compare_value_boundaries),
+ KUNIT_CASE(hpcc_test_compare_counter_boundaries),
KUNIT_CASE(hpcc_test_init_one),
KUNIT_CASE(hpcc_test_set),
{}
--
2.51.0
next prev parent reply other threads:[~2026-03-16 14:38 UTC|newest]
Thread overview: 5+ messages / expand[flat|nested] mbox.gz Atom feed top
2026-03-16 14:38 [PATCH 1/2] lib: fix compare_delta parameter order in percpu_counter_tree David Carlier
2026-03-16 14:38 ` David Carlier [this message]
2026-03-16 14:40 ` [PATCH 2/2] lib: add kunit boundary tests for percpu_counter_tree comparisons Mathieu Desnoyers
2026-03-16 15:13 ` Josh Law
2026-03-16 14:39 ` [PATCH 1/2] lib: fix compare_delta parameter order in percpu_counter_tree Mathieu Desnoyers
Reply instructions:
You may reply publicly to this message via plain-text email
using any one of the following methods:
* Save the following mbox file, import it into your mail client,
and reply-to-all from there: mbox
Avoid top-posting and favor interleaved quoting:
https://en.wikipedia.org/wiki/Posting_style#Interleaved_style
* Reply using the --to, --cc, and --in-reply-to
switches of git-send-email(1):
git send-email \
--in-reply-to=20260316143805.36805-2-devnexen@gmail.com \
--to=devnexen@gmail.com \
--cc=akpm@linux-foundation.org \
--cc=dennis@kernel.org \
--cc=linux-kernel@vger.kernel.org \
--cc=mathieu.desnoyers@efficios.com \
--cc=objecting@objecting.org \
/path/to/YOUR_REPLY
https://kernel.org/pub/software/scm/git/docs/git-send-email.html
* If your mail client supports setting the In-Reply-To header
via mailto: links, try the mailto: link
Be sure your reply has a Subject: header at the top and a blank line
before the message body.
This is an external index of several public inboxes,
see mirroring instructions on how to clone and mirror
all data and code used by this external index.