test: add reciprocal based division

This commit provides a set of tests for verifying the correctness and
performance of both unsigned 32 and 64bit reciprocal based division.

Signed-off-by: Pavan Nikhilesh <pbhagavatula@caviumnetworks.com>

diff --git a/MAINTAINERS b/MAINTAINERS
index 5788ea0..eea4cf4 100644 (file)
--- a/MAINTAINERS
+++ b/MAINTAINERS
@@ -108,6 +108,7 @@ F: test/test/test_logs.c
 F: test/test/test_memcpy*
 F: test/test/test_per_lcore.c
 F: test/test/test_prefetch.c
+F: test/test/test_reciprocal_division*
 F: test/test/test_rwlock.c
 F: test/test/test_spinlock.c
 F: test/test/test_string_fns.c

diff --git a/test/test/Makefile b/test/test/Makefile
index 5ba5a9a..c943a92 100644 (file)
--- a/test/test/Makefile
+++ b/test/test/Makefile
@@ -67,6 +67,8 @@ SRCS-y += test_spinlock.c
 SRCS-y += test_memory.c
 SRCS-y += test_memzone.c
 SRCS-y += test_bitmap.c
+SRCS-y += test_reciprocal_division.c
+SRCS-y += test_reciprocal_division_perf.c
 
 SRCS-y += test_ring.c
 SRCS-y += test_ring_perf.c

diff --git a/test/test/test_reciprocal_division.c b/test/test/test_reciprocal_division.c
new file mode 100644 (file)
index 0000000..8ea9b1d
--- /dev/null
+++ b/test/test/test_reciprocal_division.c
@@ -0,0 +1,167 @@
+/* SPDX-License-Identifier: BSD-3-Clause
+ * Copyright(c) 2017 Cavium, Inc
+ */
+
+#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)
+
+static int
+test_reciprocal(void)
+{
+       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};
+
+       rte_srand(rte_rdtsc());
+       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;
+               }
+       }
+
+       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);
+               }
+
+               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;
+               }
+       }
+
+       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);
+               }
+
+               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;
+               }
+       }
+
+       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);
+
+               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,
+                                       &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(
+                                       (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;
+                       }
+               }
+       }
+
+       for (; i < 64; i++) {
+               divisor_u64 = 1ull << i;
+               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,
+                                       &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;
+                       }
+               }
+       }
+
+       return result;
+}
+
+REGISTER_TEST_COMMAND(reciprocal_division, test_reciprocal);

diff --git a/test/test/test_reciprocal_division_perf.c b/test/test/test_reciprocal_division_perf.c
new file mode 100644 (file)
index 0000000..a7be8aa
--- /dev/null
+++ b/test/test/test_reciprocal_division_perf.c
@@ -0,0 +1,201 @@
+/* SPDX-License-Identifier: BSD-3-Clause
+ * Copyright(c) 2017 Cavium, Inc
+ */
+
+#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    (1ULL << 28)
+
+static int
+test_reciprocal_division_perf(void)
+{
+       int result = 0;
+       uint32_t divisor_u32 = 0;
+       uint32_t dividend_u32;
+       uint64_t divisor_u64 = 0;
+       uint64_t dividend_u64;
+       volatile uint32_t nresult_u32;
+       volatile uint32_t rresult_u32;
+       volatile uint64_t nresult_u64;
+       volatile uint64_t rresult_u64;
+       uint64_t start_cyc;
+       uint64_t split_cyc;
+       uint64_t end_cyc;
+       uint64_t tot_cyc_n = 0;
+       uint64_t tot_cyc_r = 0;
+       uint64_t i;
+       struct rte_reciprocal reci_u32 = {0};
+       struct rte_reciprocal_u64 reci_u64 = {0};
+
+       rte_srand(rte_rdtsc());
+
+       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();
+
+               start_cyc = rte_rdtsc();
+               nresult_u32 = dividend_u32 / divisor_u32;
+               split_cyc = rte_rdtsc();
+               rresult_u32 = rte_reciprocal_divide(dividend_u32,
+                               reci_u32);
+               end_cyc = rte_rdtsc();
+
+               tot_cyc_n += split_cyc - start_cyc;
+               tot_cyc_r += end_cyc - split_cyc;
+               if (nresult_u32 != rresult_u32) {
+                       printf("Division failed, expected %"PRIu32" "
+                                       "result %"PRIu32"",
+                                       nresult_u32, rresult_u32);
+                       result = 1;
+                       break;
+               }
+       }
+       printf("32bit Division results:\n");
+       printf("Total number of cycles normal division     : %"PRIu64"\n",
+                       tot_cyc_n);
+       printf("Total number of cycles reciprocal division : %"PRIu64"\n",
+                       tot_cyc_r);
+       printf("Cycles per division(normal) : %3.2f\n",
+                       ((double)tot_cyc_n)/i);
+       printf("Cycles per division(reciprocal) : %3.2f\n\n",
+                       ((double)tot_cyc_r)/i);
+
+       tot_cyc_n = 0;
+       tot_cyc_r = 0;
+
+       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);
+               }
+
+               dividend_u64 = rte_rand();
+
+               start_cyc = rte_rdtsc();
+               nresult_u64 = dividend_u64 / divisor_u64;
+               split_cyc = rte_rdtsc();
+               rresult_u64 = rte_reciprocal_divide_u64(dividend_u64,
+                               &reci_u64);
+               end_cyc = rte_rdtsc();
+
+               tot_cyc_n += split_cyc - start_cyc;
+               tot_cyc_r += end_cyc - split_cyc;
+               if (nresult_u64 != rresult_u64) {
+                       printf("Division failed, expected %"PRIu64" "
+                                       "result %"PRIu64"",
+                                       nresult_u64, rresult_u64);
+                       result = 1;
+                       break;
+               }
+       }
+       printf("64bit Division results:\n");
+       printf("Total number of cycles normal division     : %"PRIu64"\n",
+                       tot_cyc_n);
+       printf("Total number of cycles reciprocal division : %"PRIu64"\n",
+                       tot_cyc_r);
+       printf("Cycles per division(normal) : %3.2f\n",
+                       ((double)tot_cyc_n)/i);
+       printf("Cycles per division(reciprocal) : %3.2f\n\n",
+                       ((double)tot_cyc_r)/i);
+
+       tot_cyc_n = 0;
+       tot_cyc_r = 0;
+
+       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);
+               }
+
+               dividend_u64 = rte_rand();
+
+               start_cyc = rte_rdtsc();
+               nresult_u64 = dividend_u64 / divisor_u64;
+               split_cyc = rte_rdtsc();
+               rresult_u64 = rte_reciprocal_divide_u64(dividend_u64,
+                               &reci_u64);
+               end_cyc = rte_rdtsc();
+
+               tot_cyc_n += split_cyc - start_cyc;
+               tot_cyc_r += end_cyc - split_cyc;
+               if (nresult_u64 != rresult_u64) {
+                       printf("Division failed, expected %"PRIu64" "
+                                       "result %"PRIu64"",
+                                       nresult_u64, rresult_u64);
+                       result = 1;
+                       break;
+               }
+       }
+
+       printf("64bit Division results:\n");
+       printf("Total number of cycles normal division     : %"PRIu64"\n",
+                       tot_cyc_n);
+       printf("Total number of cycles reciprocal division : %"PRIu64"\n",
+                       tot_cyc_r);
+       printf("Cycles per division(normal) : %3.2f\n",
+                       ((double)tot_cyc_n)/i);
+       printf("Cycles per division(reciprocal) : %3.2f\n\n",
+                       ((double)tot_cyc_r)/i);
+
+       tot_cyc_n = 0;
+       tot_cyc_r = 0;
+
+       printf("Validating division by power of 2.\n");
+       for (i = 0; i < 64; i++) {
+               divisor_u64 = 1ull << i;
+               reci_u64 = rte_reciprocal_value_u64(divisor_u64);
+
+               dividend_u64 = rte_rand();
+
+               start_cyc = rte_rdtsc();
+               nresult_u64 = dividend_u64 / divisor_u64;
+               split_cyc = rte_rdtsc();
+               rresult_u64 = rte_reciprocal_divide_u64(dividend_u64,
+                               &reci_u64);
+               end_cyc = rte_rdtsc();
+
+               tot_cyc_n += split_cyc - start_cyc;
+               tot_cyc_r += end_cyc - split_cyc;
+               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;
+                       break;
+               }
+       }
+       printf("64bit Division results:\n");
+       printf("Total number of cycles normal division     : %"PRIu64"\n",
+                       tot_cyc_n);
+       printf("Total number of cycles reciprocal division : %"PRIu64"\n",
+                       tot_cyc_r);
+       printf("Cycles per division(normal) : %3.2f\n",
+                       ((double)tot_cyc_n)/i);
+       printf("Cycles per division(reciprocal) : %3.2f\n",
+                       ((double)tot_cyc_r)/i);
+
+       return result;
+}
+
+REGISTER_TEST_COMMAND(reciprocal_division_perf, test_reciprocal_division_perf);