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 a public inbox, see mirroring instructions
for how to clone and mirror all data and code used for this inbox