[ceph.git] / ceph / src / spdk / dpdk / test / test / test_reciprocal_division.c

/* 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);
Commit	Line	Data
11fdf7f2 TL	1	/* SPDX-License-Identifier: BSD-3-Clause
	2	* Copyright(c) 2017 Cavium, Inc
	3	*/
	4
	5	#include "test.h"
	6
	7	#include <stdio.h>
	8	#include <unistd.h>
	9	#include <inttypes.h>
	10
	11	#include <rte_common.h>
	12	#include <rte_cycles.h>
	13	#include <rte_random.h>
	14	#include <rte_reciprocal.h>
	15
	16	#define MAX_ITERATIONS (1ULL << 32)
	17	#define DIVIDE_ITER (100)
	18
	19	static int
	20	test_reciprocal(void)
	21	{
	22	int result = 0;
	23	uint32_t divisor_u32 = 0;
	24	uint32_t dividend_u32;
	25	uint32_t nresult_u32;
	26	uint32_t rresult_u32;
	27	uint64_t i, j;
	28	uint64_t divisor_u64 = 0;
	29	uint64_t dividend_u64;
	30	uint64_t nresult_u64;
	31	uint64_t rresult_u64;
	32	struct rte_reciprocal reci_u32 = {0};
	33	struct rte_reciprocal_u64 reci_u64 = {0};
	34
	35	rte_srand(rte_rdtsc());
	36	printf("Validating unsigned 32bit division.\n");
	37	for (i = 0; i < MAX_ITERATIONS; i++) {
	38	/* Change divisor every DIVIDE_ITER iterations. */
	39	if (i % DIVIDE_ITER == 0) {
	40	divisor_u32 = rte_rand();
	41	reci_u32 = rte_reciprocal_value(divisor_u32);
	42	}
	43
	44	dividend_u32 = rte_rand();
	45	nresult_u32 = dividend_u32 / divisor_u32;
	46	rresult_u32 = rte_reciprocal_divide(dividend_u32,
	47	reci_u32);
	48	if (nresult_u32 != rresult_u32) {
	49	printf("Division failed, %"PRIu32"/%"PRIu32" = "
	50	"expected %"PRIu32" result %"PRIu32"\n",
	51	dividend_u32, divisor_u32,
	52	nresult_u32, rresult_u32);
	53	result = 1;
	54	break;
	55	}
	56	}
	57
	58	printf("Validating unsigned 64bit division.\n");
	59	for (i = 0; i < MAX_ITERATIONS; i++) {
	60	/* Change divisor every DIVIDE_ITER iterations. */
	61	if (i % DIVIDE_ITER == 0) {
	62	divisor_u64 = rte_rand();
	63	reci_u64 = rte_reciprocal_value_u64(divisor_u64);
	64	}
65
66	dividend_u64 = rte_rand();
67	nresult_u64 = dividend_u64 / divisor_u64;
68	rresult_u64 = rte_reciprocal_divide_u64(dividend_u64,
69	&reci_u64);
70	if (nresult_u64 != rresult_u64) {
71	printf("Division failed, %"PRIu64"/%"PRIu64" = "
72	"expected %"PRIu64" result %"PRIu64"\n",
73	dividend_u64, divisor_u64,
74	nresult_u64, rresult_u64);
75	result = 1;
76	break;
77	}
78	}
79
80	printf("Validating unsigned 64bit division with 32bit divisor.\n");
81	for (i = 0; i < MAX_ITERATIONS; i++) {
82	/* Change divisor every DIVIDE_ITER iterations. */
83	if (i % DIVIDE_ITER == 0) {
84	divisor_u64 = rte_rand() >> 32;
85	reci_u64 = rte_reciprocal_value_u64(divisor_u64);
86	}
87
88	dividend_u64 = rte_rand();
89
90	nresult_u64 = dividend_u64 / divisor_u64;
91	rresult_u64 = rte_reciprocal_divide_u64(dividend_u64,
92	&reci_u64);
93
94	if (nresult_u64 != rresult_u64) {
95	printf("Division failed, %"PRIu64"/%"PRIu64" = "
96	"expected %"PRIu64" result %"PRIu64"\n",
97	dividend_u64, divisor_u64,
98	nresult_u64, rresult_u64);
99	result = 1;
100	break;
101	}
102	}
103
104	printf("Validating division by power of 2.\n");
105	for (i = 0; i < 32; i++) {
106	divisor_u64 = 1ull << i;
107	reci_u64 = rte_reciprocal_value_u64(divisor_u64);
108	reci_u32 = rte_reciprocal_value((uint32_t)divisor_u64);
109
110	for (j = 0; j < MAX_ITERATIONS >> 4; j++) {
111	dividend_u64 = rte_rand();
112
113	nresult_u64 = dividend_u64 / divisor_u64;
114	rresult_u64 = rte_reciprocal_divide_u64(dividend_u64,
115	&reci_u64);
116
117	if (nresult_u64 != rresult_u64) {
118	printf(
119	"Division 64 failed, %"PRIu64"/%"PRIu64" = "
120	"expected %"PRIu64" result %"PRIu64"\n",
121	dividend_u64, divisor_u64,
122	nresult_u64, rresult_u64);
123	result = 1;
124	}
125
126	nresult_u32 = (dividend_u64 >> 32) / divisor_u64;
127	rresult_u32 = rte_reciprocal_divide(
128	(dividend_u64 >> 32), reci_u32);
129
130	if (nresult_u32 != rresult_u32) {
131	printf(
132	"Division 32 failed, %"PRIu64"/%"PRIu64" = "
133	"expected %"PRIu64" result %"PRIu64"\n",
134	dividend_u64 >> 32, divisor_u64,
135	nresult_u64, rresult_u64);
136	result = 1;
137	break;
138	}
139	}
140	}
141
142	for (; i < 64; i++) {
143	divisor_u64 = 1ull << i;
144	reci_u64 = rte_reciprocal_value_u64(divisor_u64);
145
146	for (j = 0; j < MAX_ITERATIONS >> 4; j++) {
147	dividend_u64 = rte_rand();
148
149	nresult_u64 = dividend_u64 / divisor_u64;
150	rresult_u64 = rte_reciprocal_divide_u64(dividend_u64,
151	&reci_u64);
152
153	if (nresult_u64 != rresult_u64) {
154	printf("Division failed, %"PRIu64"/%"PRIu64" = "
155	"expected %"PRIu64" result %"PRIu64"\n",
156	dividend_u64, divisor_u64,
157	nresult_u64, rresult_u64);
158	result = 1;
159	break;
160	}
161	}
162	}
163
164	return result;
165	}
166
167	REGISTER_TEST_COMMAND(reciprocal_division, test_reciprocal);