[PATCH 1/7] app/test/reciprocal_division: make it a fast test

[Stephen Hemminger <stephen@networkplumber.org>]

This test is useful to have in CI, but the iteration values
were too large to make it usable as a fast test.

Redo the test with checks around boundary values and
use unit test framework for sub tests.

Signed-off-by: Stephen Hemminger <stephen@networkplumber.org>
---
 app/test/test_reciprocal_division.c | 279 ++++++++++++++++------------
 1 file changed, 157 insertions(+), 122 deletions(-)

diff --git a/app/test/test_reciprocal_division.c b/app/test/test_reciprocal_division.c
index 3d0736d8dd..80f8561523 100644
--- a/app/test/test_reciprocal_division.c
+++ b/app/test/test_reciprocal_division.c
@@ -5,162 +5,197 @@
 #include "test.h"
 
 #include <stdio.h>
-#include <unistd.h>
 #include <inttypes.h>
 
 #include <rte_common.h>
-#include <rte_cycles.h>
 #include <rte_random.h>
 #include <rte_reciprocal.h>
 
-#define MAX_ITERATIONS	(1ULL << 32)
-#define DIVIDE_ITER	(100)
+#define MAX_ITERATIONS	(1ULL << 20)
+#define DIVISORS_RANDOM 64
 
 static int
-test_reciprocal(void)
+test_u32_divide(uint32_t a, uint32_t d, struct rte_reciprocal r)
 {
-	int result = 0;
-	uint32_t divisor_u32 = 0;
-	uint32_t dividend_u32;
-	uint32_t nresult_u32;
-	uint32_t rresult_u32;
-	uint64_t i, j;
-	uint64_t divisor_u64 = 0;
-	uint64_t dividend_u64;
-	uint64_t nresult_u64;
-	uint64_t rresult_u64;
-	struct rte_reciprocal reci_u32 = {0};
-	struct rte_reciprocal_u64 reci_u64 = {0};
-
-	printf("Validating unsigned 32bit division.\n");
-	for (i = 0; i < MAX_ITERATIONS; i++) {
-		/* Change divisor every DIVIDE_ITER iterations. */
-		if (i % DIVIDE_ITER == 0) {
-			divisor_u32 = rte_rand();
-			reci_u32 = rte_reciprocal_value(divisor_u32);
-		}
-
-		dividend_u32 = rte_rand();
-		nresult_u32 = dividend_u32 / divisor_u32;
-		rresult_u32 = rte_reciprocal_divide(dividend_u32,
-				reci_u32);
-		if (nresult_u32 != rresult_u32) {
-			printf("Division failed, %"PRIu32"/%"PRIu32" = "
-					"expected %"PRIu32" result %"PRIu32"\n",
-					dividend_u32, divisor_u32,
-					nresult_u32, rresult_u32);
-			result = 1;
-			break;
-		}
-	}
+	uint32_t expected = a / d;
+	uint32_t result = rte_reciprocal_divide(a, r);
 
-	printf("Validating unsigned 64bit division.\n");
-	for (i = 0; i < MAX_ITERATIONS; i++) {
-		/* Change divisor every DIVIDE_ITER iterations. */
-		if (i % DIVIDE_ITER == 0) {
-			divisor_u64 = rte_rand();
-			reci_u64 = rte_reciprocal_value_u64(divisor_u64);
-		}
+	TEST_ASSERT_EQUAL(expected, result,
+			  "%"PRIu32"/%"PRIu32" expected %"PRIu32" got %"PRIu32,
+			  a, d, expected, result);
+	return 0;
+}
 
-		dividend_u64 = rte_rand();
-		nresult_u64 = dividend_u64 / divisor_u64;
-		rresult_u64 = rte_reciprocal_divide_u64(dividend_u64,
-				&reci_u64);
-		if (nresult_u64 != rresult_u64) {
-			printf("Division failed,  %"PRIu64"/%"PRIu64" = "
-					"expected %"PRIu64" result %"PRIu64"\n",
-					dividend_u64, divisor_u64,
-					nresult_u64, rresult_u64);
-			result = 1;
-			break;
+static int
+test_reciprocal_u32(void)
+{
+	const uint32_t edge_div_u32[] = {
+		1, 2, 3, 7, 0x7fffffff, 0x80000000, 0xfffffffe, UINT32_MAX,
+	};
+	unsigned int n_div = RTE_DIM(edge_div_u32) + DIVISORS_RANDOM;
+
+	for (unsigned int di = 0; di < n_div; di++) {
+		uint32_t d;
+		if (di < RTE_DIM(edge_div_u32))
+			d = edge_div_u32[di]; /* Make sure and test the edge cases */
+		else
+			d = rte_rand_max(UINT32_MAX - 1) + 1;
+
+		struct rte_reciprocal r = rte_reciprocal_value(d);
+		uint32_t qmax = UINT32_MAX / d;   /* largest q with q*d <= UINT32_MAX */
+		if (d != 1)
+			qmax++;
+
+		for (unsigned int k = 0; k < MAX_ITERATIONS; k++) {
+			uint32_t q = rte_rand_max(qmax);
+			uint32_t val = q * d;           /* fits in u32 */
+
+			/* Check around the value.
+			 * Under and overflow of 32 bit value are fine here.
+			 */
+			if (test_u32_divide(val - 1, d, r) < 0 ||
+			    test_u32_divide(val, d, r) < 0 ||
+			    test_u32_divide(val + 1, d, r) < 0)
+				return -1;
 		}
 	}
+	return TEST_SUCCESS;
+}
 
-	printf("Validating unsigned 64bit division with 32bit divisor.\n");
-	for (i = 0; i < MAX_ITERATIONS; i++) {
-		/* Change divisor every DIVIDE_ITER iterations. */
-		if (i % DIVIDE_ITER == 0) {
-			divisor_u64 = rte_rand() >> 32;
-			reci_u64 = rte_reciprocal_value_u64(divisor_u64);
-		}
+static int
+test_u64_divide(uint64_t a, uint64_t d, const struct rte_reciprocal_u64 *r)
+{
+	uint64_t expected = a / d;
+	uint64_t result = rte_reciprocal_divide_u64(a, r);
+
+	TEST_ASSERT_EQUAL(expected, result,
+			  "%"PRIu64"/%"PRIu64" expected %"PRIu64" got %"PRIu64,
+			  a, d, expected, result);
+	return 0;
+}
 
-		dividend_u64 = rte_rand();
 
-		nresult_u64 = dividend_u64 / divisor_u64;
-		rresult_u64 = rte_reciprocal_divide_u64(dividend_u64,
-				&reci_u64);
+static int
+test_reciprocal_u64(void)
+{
+	const uint64_t edge_div_u64[] = {
+		1, 2, 3, 7, 0x7fffffff, 0x80000000, 0xfffffffe, UINT64_MAX,
+	};
+	unsigned int n_div = RTE_DIM(edge_div_u64) + DIVISORS_RANDOM;
+
+	for (unsigned int di = 0; di < n_div; di++) {
+		uint64_t d;
+		if (di < RTE_DIM(edge_div_u64))
+			d = edge_div_u64[di];
+		else
+			d = rte_rand_max(UINT64_MAX - 1) + 1;
+
+		struct rte_reciprocal_u64 r = rte_reciprocal_value_u64(d);
+		uint64_t qmax = UINT64_MAX / d;   /* largest q with q*d <= UINT64_MAX */
+		if (d != 1)
+			++qmax;
+
+		for (unsigned int k = 0; k < MAX_ITERATIONS; k++) {
+			uint64_t q = rte_rand_max(qmax);
+			uint64_t val = q * d;
+
+			if (test_u64_divide(val - 1, d, &r) < 0 ||
+			    test_u64_divide(val, d, &r) < 0 ||
+			    test_u64_divide(val + 1, d, &r) < 0)
+				return -1;
 
-		if (nresult_u64 != rresult_u64) {
-			printf("Division failed, %"PRIu64"/%"PRIu64" = "
-					"expected %"PRIu64" result %"PRIu64"\n",
-					dividend_u64, divisor_u64,
-					nresult_u64, rresult_u64);
-			result = 1;
-			break;
 		}
 	}
+	return TEST_SUCCESS;
+}
 
-	printf("Validating division by power of 2.\n");
-	for (i = 0; i < 32; i++) {
-		divisor_u64 = 1ull << i;
-		reci_u64 = rte_reciprocal_value_u64(divisor_u64);
-		reci_u32 = rte_reciprocal_value((uint32_t)divisor_u64);
+static int
+test_reciprocal_u64_small(void)
+{
+	/* 64-bit division with a 32-bit-range divisor */
+	uint64_t divisor_u64 = (rte_rand() >> 32) | 1;
+	struct rte_reciprocal_u64 reci_u64 = rte_reciprocal_value_u64(divisor_u64);
+
+	for (unsigned int i = 0; i < MAX_ITERATIONS; i++) {
+		uint64_t dividend_u64 = rte_rand();
+		uint64_t nresult_u64 = dividend_u64 / divisor_u64;
+		uint64_t rresult_u64 = rte_reciprocal_divide_u64(dividend_u64, &reci_u64);
+
+		TEST_ASSERT_EQUAL(nresult_u64, rresult_u64,
+			"%"PRIu64"/%"PRIu64" = expected %"PRIu64" got %"PRIu64,
+			dividend_u64, divisor_u64, nresult_u64, rresult_u64);
+	}
 
-		for (j = 0; j < MAX_ITERATIONS >> 4; j++) {
-			dividend_u64 = rte_rand();
+	return TEST_SUCCESS;
+}
 
-			nresult_u64 = dividend_u64 / divisor_u64;
-			rresult_u64 = rte_reciprocal_divide_u64(dividend_u64,
+static int
+test_reciprocal_pow2(void)
+{
+	for (unsigned int i = 0; i < 32; i++) {
+		uint64_t divisor_u64 = 1ULL << i;
+		struct rte_reciprocal_u64 reci_u64 = rte_reciprocal_value_u64(divisor_u64);
+		struct rte_reciprocal reci_u32 = rte_reciprocal_value((uint32_t)divisor_u64);
+
+		for (unsigned int j = 0; j < MAX_ITERATIONS >> 4; j++) {
+			uint64_t dividend_u64 = rte_rand();
+			uint64_t nresult_u64 = dividend_u64 / divisor_u64;
+			uint64_t rresult_u64 = rte_reciprocal_divide_u64(dividend_u64,
 					&reci_u64);
 
-			if (nresult_u64 != rresult_u64) {
-				printf(
-				"Division 64 failed, %"PRIu64"/%"PRIu64" = "
-					"expected %"PRIu64" result %"PRIu64"\n",
-						dividend_u64, divisor_u64,
-						nresult_u64, rresult_u64);
-				result = 1;
-			}
-
-			nresult_u32 = (dividend_u64 >> 32) / divisor_u64;
-			rresult_u32 = rte_reciprocal_divide(
+			TEST_ASSERT_EQUAL(nresult_u64, rresult_u64,
+				"u64 %"PRIu64"/%"PRIu64" = expected %"PRIu64" got %"PRIu64,
+				dividend_u64, divisor_u64,
+				nresult_u64, rresult_u64);
+
+			uint32_t nresult_u32 = (dividend_u64 >> 32) / divisor_u64;
+			uint32_t rresult_u32 = rte_reciprocal_divide(
 					(dividend_u64 >> 32), reci_u32);
 
-			if (nresult_u32 != rresult_u32) {
-				printf(
-				"Division 32 failed, %"PRIu64"/%"PRIu64" = "
-					"expected %"PRIu64" result %"PRIu64"\n",
-						dividend_u64 >> 32, divisor_u64,
-						nresult_u64, rresult_u64);
-				result = 1;
-				break;
-			}
+			TEST_ASSERT_EQUAL(nresult_u32, rresult_u32,
+				"u32 %"PRIu64"/%"PRIu64" = expected %"PRIu32" got %"PRIu32,
+				dividend_u64 >> 32, divisor_u64,
+				nresult_u32, rresult_u32);
 		}
 	}
 
-	for (; i < 64; i++) {
-		divisor_u64 = 1ull << i;
-		reci_u64 = rte_reciprocal_value_u64(divisor_u64);
+	for (unsigned int i = 32; i < 64; i++) {
+		uint64_t divisor_u64 = 1ULL << i;
+		struct rte_reciprocal_u64 reci_u64 = rte_reciprocal_value_u64(divisor_u64);
 
-		for (j = 0; j < MAX_ITERATIONS >> 4; j++) {
-			dividend_u64 = rte_rand();
-
-			nresult_u64 = dividend_u64 / divisor_u64;
-			rresult_u64 = rte_reciprocal_divide_u64(dividend_u64,
+		for (unsigned int j = 0; j < MAX_ITERATIONS >> 4; j++) {
+			uint64_t dividend_u64 = rte_rand();
+			uint64_t nresult_u64 = dividend_u64 / divisor_u64;
+			uint64_t rresult_u64 = rte_reciprocal_divide_u64(dividend_u64,
 					&reci_u64);
 
-			if (nresult_u64 != rresult_u64) {
-				printf("Division failed, %"PRIu64"/%"PRIu64" = "
-					"expected %"PRIu64" result %"PRIu64"\n",
-						dividend_u64, divisor_u64,
-						nresult_u64, rresult_u64);
-				result = 1;
-				break;
-			}
+			TEST_ASSERT_EQUAL(nresult_u64, rresult_u64,
+				"u64 %"PRIu64"/%"PRIu64" = expected %"PRIu64" got %"PRIu64,
+				dividend_u64, divisor_u64,
+				nresult_u64, rresult_u64);
 		}
 	}
 
-	return result;
+	return TEST_SUCCESS;
+}
+
+static struct unit_test_suite reciprocal_tests = {
+	.suite_name = "reciprocal division autotest",
+	.setup = NULL,
+	.teardown = NULL,
+	.unit_test_cases = {
+		TEST_CASE(test_reciprocal_u32),
+		TEST_CASE(test_reciprocal_u64),
+		TEST_CASE(test_reciprocal_u64_small),
+		TEST_CASE(test_reciprocal_pow2),
+		TEST_CASES_END()
+	}
+};
+
+static int
+test_reciprocal(void)
+{
+	return unit_test_suite_runner(&reciprocal_tests);
 }
 
-REGISTER_PERF_TEST(reciprocal_division, test_reciprocal);
+REGISTER_FAST_TEST(reciprocal_division_autotest, NOHUGE_OK, ASAN_OK, test_reciprocal);
-- 
2.53.0