1 /* SPDX-License-Identifier: BSD-3-Clause
2 * Copyright(c) 2010-2014 Intel Corporation
8 #include <rte_common.h>
9 #include <rte_hexdump.h>
10 #include <rte_pause.h>
14 #define MAX_NUM 1 << 20
17 {printf(x "() test failed!\n");\
20 /* this is really a sanity check */
22 test_macros(int __rte_unused unused_parm)
24 #define SMALLER 0x1000U
25 #define BIGGER 0x2000U
26 #define PTR_DIFF BIGGER - SMALLER
27 #define FAIL_MACRO(x)\
28 {printf(#x "() test failed!\n");\
35 if ((uintptr_t)RTE_PTR_ADD(SMALLER, PTR_DIFF) != BIGGER)
36 FAIL_MACRO(RTE_PTR_ADD);
37 if ((uintptr_t)RTE_PTR_SUB(BIGGER, PTR_DIFF) != SMALLER)
38 FAIL_MACRO(RTE_PTR_SUB);
39 if (RTE_PTR_DIFF(BIGGER, SMALLER) != PTR_DIFF)
40 FAIL_MACRO(RTE_PTR_DIFF);
41 if (RTE_MAX(SMALLER, BIGGER) != BIGGER)
43 if (RTE_MIN(SMALLER, BIGGER) != SMALLER)
46 if (strncmp(RTE_STR(test), "test", sizeof("test")))
55 char memdump[] = "memdump_test";
59 rte_memdump(stdout, "test", memdump, sizeof(memdump));
60 rte_hexdump(stdout, "test", memdump, sizeof(memdump));
70 #define FAIL_ALIGN(x, i, p)\
71 {printf(x "() test failed: %u %u\n", i, p);\
73 #define ERROR_FLOOR(res, i, pow) \
74 (res % pow) || /* check if not aligned */ \
75 ((res / pow) != (i / pow)) /* check if correct alignment */
76 #define ERROR_CEIL(res, i, pow) \
77 (res % pow) || /* check if not aligned */ \
78 ((i % pow) == 0 ? /* check if ceiling is invoked */ \
79 val / pow != i / pow : /* if aligned */ \
80 val / pow != (i / pow) + 1) /* if not aligned, hence +1 */
84 for (i = 1, p = 1; i <= MAX_NUM; i ++) {
85 if (rte_align32pow2(i) != p)
86 FAIL_ALIGN("rte_align32pow2", i, p);
91 for (p = 2; p <= MAX_NUM; p <<= 1) {
93 if (!rte_is_power_of_2(p))
94 FAIL("rte_is_power_of_2");
96 for (i = 1; i <= MAX_NUM; i++) {
98 if (RTE_ALIGN_FLOOR((uintptr_t)i, p) % p)
99 FAIL_ALIGN("RTE_ALIGN_FLOOR", i, p);
101 val = RTE_PTR_ALIGN_FLOOR((uintptr_t) i, p);
102 if (ERROR_FLOOR(val, i, p))
103 FAIL_ALIGN("RTE_PTR_ALIGN_FLOOR", i, p);
105 val = RTE_ALIGN_FLOOR(i, p);
106 if (ERROR_FLOOR(val, i, p))
107 FAIL_ALIGN("RTE_ALIGN_FLOOR", i, p);
110 val = RTE_PTR_ALIGN((uintptr_t) i, p);
111 if (ERROR_CEIL(val, i, p))
112 FAIL_ALIGN("RTE_PTR_ALIGN", i, p);
114 val = RTE_ALIGN(i, p);
115 if (ERROR_CEIL(val, i, p))
116 FAIL_ALIGN("RTE_ALIGN", i, p);
118 val = RTE_ALIGN_CEIL(i, p);
119 if (ERROR_CEIL(val, i, p))
120 FAIL_ALIGN("RTE_ALIGN_CEIL", i, p);
122 val = RTE_PTR_ALIGN_CEIL((uintptr_t)i, p);
123 if (ERROR_CEIL(val, i, p))
124 FAIL_ALIGN("RTE_PTR_ALIGN_CEIL", i, p);
126 /* by this point we know that val is aligned to p */
127 if (!rte_is_aligned((void*)(uintptr_t) val, p))
128 FAIL("rte_is_aligned");
137 uint32_t i, base, compare;
138 const uint32_t max = 0x10000;
139 const uint32_t step = 1;
141 for (i = 0; i < max; i = i + step) {
142 base = (uint32_t)ceilf(log2((uint32_t)i));
143 compare = rte_log2_u32(i);
144 if (base != compare) {
145 printf("Wrong rte_log2_u32(%x) val %x, expected %x\n",
158 ret |= test_macros(0);
165 REGISTER_TEST_COMMAND(common_autotest, test_common);