Add a C99 test program (ridiculousfish#79)

adbancroft · web-flow · commit a551b6cc0bc1 · 2021-07-06T17:01:46.000-05:00
* Add C99 test program

* Fix C99 issues

Change out static_cast to C-style cast
Rename functions to avoid overloading:
  libdivide_s64_signbits_vec512
  libdivide_s64_signbits_vec256
  libdivide_s64_signbits_vec128
diff --git a/CMakeLists.txt b/CMakeLists.txt
@@ -255,19 +255,24 @@ if (BUILD_TESTS)
     find_package(Threads REQUIRED QUIET)
 
     add_executable(tester test/tester.cpp)
+    add_executable(test_c99 test/test_c99.c)
     add_executable(benchmark test/benchmark.cpp)
     add_executable(benchmark_branchfree test/benchmark_branchfree.cpp)
 
     target_link_libraries(tester libdivide Threads::Threads)
+    target_link_libraries(test_c99 libdivide)
     target_link_libraries(benchmark libdivide)
     target_link_libraries(benchmark_branchfree libdivide)
 
     target_compile_options(tester PRIVATE "${LIBDIVIDE_FLAGS}" "${NO_VECTORIZE}")
+    target_compile_options(test_c99 PRIVATE "${LIBDIVIDE_FLAGS}" "${NO_VECTORIZE}")
     target_compile_options(benchmark PRIVATE "${LIBDIVIDE_FLAGS}" "${NO_VECTORIZE_C}")
     target_compile_options(benchmark_branchfree PRIVATE "${LIBDIVIDE_FLAGS}" "${NO_VECTORIZE}")
     set_property(TARGET benchmark_branchfree PROPERTY CXX_STANDARD 11)
+    set_property(TARGET test_c99 PROPERTY C_STANDARD 99)
 
     target_compile_definitions(tester PRIVATE "${LIBDIVIDE_ASSERTIONS}" "${LIBDIVIDE_VECTOR_EXT}")
+    target_compile_definitions(test_c99 PRIVATE "${LIBDIVIDE_ASSERTIONS}" "${LIBDIVIDE_VECTOR_EXT}")
     target_compile_definitions(benchmark PRIVATE "${LIBDIVIDE_ASSERTIONS}" "${LIBDIVIDE_VECTOR_EXT}")
     target_compile_definitions(benchmark_branchfree PRIVATE "${LIBDIVIDE_ASSERTIONS}" "${LIBDIVIDE_VECTOR_EXT}")
 endif()
diff --git a/appveyor.yml b/appveyor.yml
@@ -29,6 +29,7 @@ for:
       - cppcheck . --error-exitcode=1 --force -i doc
       - ./tester
       - ./benchmark_branchfree
+      - ./test_c99
 
   - matrix:
       only:
@@ -46,6 +47,7 @@ for:
       - cppcheck . --error-exitcode=1 --force -i doc
       - ./tester
       - ./benchmark_branchfree
+      - ./test_c99
 
   - matrix:
       only:
@@ -58,6 +60,7 @@ for:
       - cd Release
       - tester.exe
       - benchmark_branchfree.exe
+      - test_c99.exe
 
   - matrix:
       only:
@@ -73,6 +76,7 @@ for:
       - cd Release
       - tester.exe
       - benchmark_branchfree.exe
+      - test_c99.exe
 
   - matrix:
       only:
@@ -85,6 +89,7 @@ for:
       - cd Release
       - tester.exe
       - benchmark_branchfree.exe
+      - test_c99.exe
 
   - matrix:
       only:
@@ -107,5 +112,6 @@ for:
       - cd Release
       - tester.exe
       - benchmark_branchfree.exe
+      - test_c99.exe
       - cd ../test/avr
       - pio run -t Simulate -e megaatmega2560_Test
diff --git a/libdivide.code-workspace b/libdivide.code-workspace
@@ -82,7 +82,8 @@
 			"xlocale": "cpp",
 			"xlocbuf": "cpp",
 			"xlocinfo": "cpp",
-			"xlocmes": "cpp"
+			"xlocmes": "cpp",
+			"xmemory0": "c"
 		}
 	}
 }
diff --git a/libdivide.h b/libdivide.h
@@ -362,7 +362,7 @@ static LIBDIVIDE_INLINE int16_t libdivide_count_leading_zeros16(uint16_t val) {
 #elif defined(LIBDIVIDE_VC)
     unsigned long result;
     if (_BitScanReverse(&result, (unsigned long)val)) {
-        return static_cast<int16_t>(15 - result);
+        return (int16_t)(15 - result);
     }
     return 0;
 #else
@@ -676,7 +676,7 @@ static LIBDIVIDE_INLINE struct libdivide_u16_t libdivide_internal_u16_gen(
     }
 
     struct libdivide_u16_t result;
-    uint8_t floor_log_2_d = static_cast<uint8_t>(15 - libdivide_count_leading_zeros16(d));
+    uint8_t floor_log_2_d = (uint8_t)(15 - libdivide_count_leading_zeros16(d));
 
     // Power of 2
     if ((d & (d - 1)) == 0) {
@@ -1183,7 +1183,7 @@ static LIBDIVIDE_INLINE struct libdivide_s16_t libdivide_internal_s16_gen(
     if ((absD & (absD - 1)) == 0) {
         // Branchfree and normal paths are exactly the same
         result.magic = 0;
-        result.more = static_cast<uint8_t>(floor_log_2_d | (d < 0 ? LIBDIVIDE_NEGATIVE_DIVISOR : 0));
+        result.more = (uint8_t)(floor_log_2_d | (d < 0 ? LIBDIVIDE_NEGATIVE_DIVISOR : 0));
     } else {
         LIBDIVIDE_ASSERT(floor_log_2_d >= 1);
 
@@ -1198,15 +1198,15 @@ static LIBDIVIDE_INLINE struct libdivide_s16_t libdivide_internal_s16_gen(
         // This works if works if e < 2**floor_log_2_d.
         if (!branchfree && e < ((uint16_t)1 << floor_log_2_d)) {
             // This power works
-            more = static_cast<uint8_t>(floor_log_2_d - 1);
+            more = (uint8_t)(floor_log_2_d - 1);
         } else {
             // We need to go one higher. This should not make proposed_m
             // overflow, but it will make it negative when interpreted as an
             // int16_t.
             proposed_m += proposed_m;
             const uint16_t twice_rem = rem + rem;
             if (twice_rem >= absD || twice_rem < rem) proposed_m += 1;
-            more = static_cast<uint8_t>(floor_log_2_d | LIBDIVIDE_ADD_MARKER);
+            more = (uint8_t)(floor_log_2_d | LIBDIVIDE_ADD_MARKER);
         }
 
         proposed_m += 1;
@@ -1703,23 +1703,23 @@ static LIBDIVIDE_INLINE int64x2_t libdivide_s64_branchfree_do_vec128(
 // Logical right shift by runtime value.
 // NEON implements right shift as left shits by negative values.
 static LIBDIVIDE_INLINE uint32x4_t libdivide_u32_neon_srl(uint32x4_t v, uint8_t amt) {
-    int32_t wamt = static_cast<int32_t>(amt);
+    int32_t wamt = (int32_t)(amt);
     return vshlq_u32(v, vdupq_n_s32(-wamt));
 }
 
 static LIBDIVIDE_INLINE uint64x2_t libdivide_u64_neon_srl(uint64x2_t v, uint8_t amt) {
-    int64_t wamt = static_cast<int64_t>(amt);
+    int64_t wamt = (int64_t)(amt);
     return vshlq_u64(v, vdupq_n_s64(-wamt));
 }
 
 // Arithmetic right shift by runtime value.
 static LIBDIVIDE_INLINE int32x4_t libdivide_s32_neon_sra(int32x4_t v, uint8_t amt) {
-    int32_t wamt = static_cast<int32_t>(amt);
+    int32_t wamt = (int32_t)(amt);
     return vshlq_s32(v, vdupq_n_s32(-wamt));
 }
 
 static LIBDIVIDE_INLINE int64x2_t libdivide_s64_neon_sra(int64x2_t v, uint8_t amt) {
-    int64_t wamt = static_cast<int64_t>(amt);
+    int64_t wamt = (int64_t)(amt);
     return vshlq_s64(v, vdupq_n_s64(-wamt));
 }
 
@@ -1771,7 +1771,7 @@ static LIBDIVIDE_INLINE uint64x2_t libdivide_mullhi_u64_vec128(uint64x2_t x, uin
 
 static LIBDIVIDE_INLINE int64x2_t libdivide_mullhi_s64_vec128(int64x2_t x, int64_t sy) {
     int64x2_t p = vreinterpretq_s64_u64(
-        libdivide_mullhi_u64_vec128(vreinterpretq_u64_s64(x), static_cast<uint64_t>(sy)));
+        libdivide_mullhi_u64_vec128(vreinterpretq_u64_s64(x), (uint64_t)(sy)));
     int64x2_t y = vdupq_n_s64(sy);
     int64x2_t t1 = vandq_s64(libdivide_s64_signbits(x), y);
     int64x2_t t2 = vandq_s64(libdivide_s64_signbits(y), x);
@@ -1998,7 +1998,7 @@ static LIBDIVIDE_INLINE __m512i libdivide_s64_branchfree_do_vec512(
 
 //////// Internal Utility Functions
 
-static LIBDIVIDE_INLINE __m512i libdivide_s64_signbits(__m512i v) {
+static LIBDIVIDE_INLINE __m512i libdivide_s64_signbits_vec512(__m512i v) {
     ;
     return _mm512_srai_epi64(v, 63);
 }
@@ -2051,8 +2051,8 @@ static LIBDIVIDE_INLINE __m512i libdivide_mullhi_u64_vec512(__m512i x, __m512i y
 // y is one 64-bit value repeated.
 static LIBDIVIDE_INLINE __m512i libdivide_mullhi_s64_vec512(__m512i x, __m512i y) {
     __m512i p = libdivide_mullhi_u64_vec512(x, y);
-    __m512i t1 = _mm512_and_si512(libdivide_s64_signbits(x), y);
-    __m512i t2 = _mm512_and_si512(libdivide_s64_signbits(y), x);
+    __m512i t1 = _mm512_and_si512(libdivide_s64_signbits_vec512(x), y);
+    __m512i t2 = _mm512_and_si512(libdivide_s64_signbits_vec512(y), x);
     p = _mm512_sub_epi64(p, t1);
     p = _mm512_sub_epi64(p, t2);
     return p;
@@ -2196,7 +2196,7 @@ __m512i libdivide_s64_do_vec512(__m512i numers, const struct libdivide_s64_t *de
         __m512i roundToZeroTweak = _mm512_set1_epi64(mask);
         // q = numer + ((numer >> 63) & roundToZeroTweak);
         __m512i q = _mm512_add_epi64(
-            numers, _mm512_and_si512(libdivide_s64_signbits(numers), roundToZeroTweak));
+            numers, _mm512_and_si512(libdivide_s64_signbits_vec512(numers), roundToZeroTweak));
         q = libdivide_s64_shift_right_vec512(q, shift);
         __m512i sign = _mm512_set1_epi32((int8_t)more >> 7);
         // q = (q ^ sign) - sign;
@@ -2233,7 +2233,7 @@ __m512i libdivide_s64_branchfree_do_vec512(
     // If q is negative, we want to add either (2**shift)-1 if d is
     // a power of 2, or (2**shift) if it is not a power of 2.
     uint32_t is_power_of_2 = (magic == 0);
-    __m512i q_sign = libdivide_s64_signbits(q);  // q_sign = q >> 63
+    __m512i q_sign = libdivide_s64_signbits_vec512(q);  // q_sign = q >> 63
     __m512i mask = _mm512_set1_epi64(((uint64_t)1 << shift) - is_power_of_2);
     q = _mm512_add_epi64(q, _mm512_and_si512(q_sign, mask));  // q = q + (q_sign & mask)
     q = libdivide_s64_shift_right_vec512(q, shift);           // q >>= shift
@@ -2274,7 +2274,7 @@ static LIBDIVIDE_INLINE __m256i libdivide_s64_branchfree_do_vec256(
 //////// Internal Utility Functions
 
 // Implementation of _mm256_srai_epi64(v, 63) (from AVX512).
-static LIBDIVIDE_INLINE __m256i libdivide_s64_signbits(__m256i v) {
+static LIBDIVIDE_INLINE __m256i libdivide_s64_signbits_vec256(__m256i v) {
     __m256i hiBitsDuped = _mm256_shuffle_epi32(v, _MM_SHUFFLE(3, 3, 1, 1));
     __m256i signBits = _mm256_srai_epi32(hiBitsDuped, 31);
     return signBits;
@@ -2333,8 +2333,8 @@ static LIBDIVIDE_INLINE __m256i libdivide_mullhi_u64_vec256(__m256i x, __m256i y
 // y is one 64-bit value repeated.
 static LIBDIVIDE_INLINE __m256i libdivide_mullhi_s64_vec256(__m256i x, __m256i y) {
     __m256i p = libdivide_mullhi_u64_vec256(x, y);
-    __m256i t1 = _mm256_and_si256(libdivide_s64_signbits(x), y);
-    __m256i t2 = _mm256_and_si256(libdivide_s64_signbits(y), x);
+    __m256i t1 = _mm256_and_si256(libdivide_s64_signbits_vec256(x), y);
+    __m256i t2 = _mm256_and_si256(libdivide_s64_signbits_vec256(y), x);
     p = _mm256_sub_epi64(p, t1);
     p = _mm256_sub_epi64(p, t2);
     return p;
@@ -2478,7 +2478,7 @@ __m256i libdivide_s64_do_vec256(__m256i numers, const struct libdivide_s64_t *de
         __m256i roundToZeroTweak = _mm256_set1_epi64x(mask);
         // q = numer + ((numer >> 63) & roundToZeroTweak);
         __m256i q = _mm256_add_epi64(
-            numers, _mm256_and_si256(libdivide_s64_signbits(numers), roundToZeroTweak));
+            numers, _mm256_and_si256(libdivide_s64_signbits_vec256(numers), roundToZeroTweak));
         q = libdivide_s64_shift_right_vec256(q, shift);
         __m256i sign = _mm256_set1_epi32((int8_t)more >> 7);
         // q = (q ^ sign) - sign;
@@ -2515,7 +2515,7 @@ __m256i libdivide_s64_branchfree_do_vec256(
     // If q is negative, we want to add either (2**shift)-1 if d is
     // a power of 2, or (2**shift) if it is not a power of 2.
     uint32_t is_power_of_2 = (magic == 0);
-    __m256i q_sign = libdivide_s64_signbits(q);  // q_sign = q >> 63
+    __m256i q_sign = libdivide_s64_signbits_vec256(q);  // q_sign = q >> 63
     __m256i mask = _mm256_set1_epi64x(((uint64_t)1 << shift) - is_power_of_2);
     q = _mm256_add_epi64(q, _mm256_and_si256(q_sign, mask));  // q = q + (q_sign & mask)
     q = libdivide_s64_shift_right_vec256(q, shift);           // q >>= shift
@@ -2556,7 +2556,7 @@ static LIBDIVIDE_INLINE __m128i libdivide_s64_branchfree_do_vec128(
 //////// Internal Utility Functions
 
 // Implementation of _mm_srai_epi64(v, 63) (from AVX512).
-static LIBDIVIDE_INLINE __m128i libdivide_s64_signbits(__m128i v) {
+static LIBDIVIDE_INLINE __m128i libdivide_s64_signbits_vec128(__m128i v) {
     __m128i hiBitsDuped = _mm_shuffle_epi32(v, _MM_SHUFFLE(3, 3, 1, 1));
     __m128i signBits = _mm_srai_epi32(hiBitsDuped, 31);
     return signBits;
@@ -2629,8 +2629,8 @@ static LIBDIVIDE_INLINE __m128i libdivide_mullhi_u64_vec128(__m128i x, __m128i y
 // y is one 64-bit value repeated.
 static LIBDIVIDE_INLINE __m128i libdivide_mullhi_s64_vec128(__m128i x, __m128i y) {
     __m128i p = libdivide_mullhi_u64_vec128(x, y);
-    __m128i t1 = _mm_and_si128(libdivide_s64_signbits(x), y);
-    __m128i t2 = _mm_and_si128(libdivide_s64_signbits(y), x);
+    __m128i t1 = _mm_and_si128(libdivide_s64_signbits_vec128(x), y);
+    __m128i t2 = _mm_and_si128(libdivide_s64_signbits_vec128(y), x);
     p = _mm_sub_epi64(p, t1);
     p = _mm_sub_epi64(p, t2);
     return p;
@@ -2774,7 +2774,7 @@ __m128i libdivide_s64_do_vec128(__m128i numers, const struct libdivide_s64_t *de
         __m128i roundToZeroTweak = _mm_set1_epi64x(mask);
         // q = numer + ((numer >> 63) & roundToZeroTweak);
         __m128i q =
-            _mm_add_epi64(numers, _mm_and_si128(libdivide_s64_signbits(numers), roundToZeroTweak));
+            _mm_add_epi64(numers, _mm_and_si128(libdivide_s64_signbits_vec128(numers), roundToZeroTweak));
         q = libdivide_s64_shift_right_vec128(q, shift);
         __m128i sign = _mm_set1_epi32((int8_t)more >> 7);
         // q = (q ^ sign) - sign;
@@ -2811,7 +2811,7 @@ __m128i libdivide_s64_branchfree_do_vec128(
     // If q is negative, we want to add either (2**shift)-1 if d is
     // a power of 2, or (2**shift) if it is not a power of 2.
     uint32_t is_power_of_2 = (magic == 0);
-    __m128i q_sign = libdivide_s64_signbits(q);  // q_sign = q >> 63
+    __m128i q_sign = libdivide_s64_signbits_vec128(q);  // q_sign = q >> 63
     __m128i mask = _mm_set1_epi64x(((uint64_t)1 << shift) - is_power_of_2);
     q = _mm_add_epi64(q, _mm_and_si128(q_sign, mask));  // q = q + (q_sign & mask)
     q = libdivide_s64_shift_right_vec128(q, shift);     // q >>= shift
diff --git a/test/test_c99.c b/test/test_c99.c
@@ -0,0 +1,93 @@
+/*
+ * A pure C test program. The point of this is to make sure libdivide
+ * will compile as C only. 
+ *
+ * Since the other programs have CPP extensions, they wil be compiled as C++. This
+ * could allow C++ syntax or programming paradigms to inadvertently creep into the 
+ * code base.  
+ */
+
+#include <stdio.h>
+#include <inttypes.h>
+#include "libdivide.h"
+
+#define UNUSED(x) (void)(x)
+#define MIN_RANGE (UINT16_MAX/4U)
+#define LOOP_STEP 3
+#define MAX(a,b) (((a) > (b)) ? (a) : (b))
+#define MIN(a,b) (((a) < (b)) ? (a) : (b))
+#define ABS(a)   MAX(-a, a)
+
+#define LOOP_START(denom) MIN(((denom*2)+LOOP_STEP), ((denom/2)+LOOP_STEP))
+#define LOOP_END(type, denom, range_max) MIN(MAX((type)MIN_RANGE, ABS(denom)*4), range_max-(LOOP_STEP*2))
+#define ASSERT_EQUAL(type, numer, denom, libdiv_result, native_result, format_spec) \
+   if (libdiv_result!=native_result) { \
+      fprintf(stderr, "Division fail: " #type ", %" format_spec "/%" format_spec ". Native: %" format_spec  ", Libdivide %" format_spec "\n", numer, denom, native_result, libdiv_result); \
+   }
+#define TEST_BODY(type, range_max, denom, divider, format_spec, OPERATION) \
+   /* We need to be careful to have a wide enough range AND increment!=1 or else GCC figures out */ \
+   /* this is a constant range and applies all sorts of optimizations */ \
+   type loop = (type)LOOP_START(denom); \
+   const type end = (type)LOOP_END(type, denom, range_max); \
+   const type step = MAX(LOOP_STEP, (end-loop)/(2<<12)); \
+   printf("Testing " #type ", %" format_spec " from %" format_spec " to %" format_spec ", step %" format_spec "\n", denom, loop, end, step); \
+   for (; loop < end; loop+=step) \
+   { \
+      type libdiv_result = OPERATION(loop); \
+      type native_result = loop / denom; \
+      ASSERT_EQUAL(type, loop, denom, libdiv_result, native_result, format_spec) \
+   }
+
+void test_u16() {
+   uint16_t denom = (uint16_t)953; // Prime
+   struct libdivide_u16_t divider = libdivide_u16_gen(denom);
+#define OP_U16(loop) libdivide_u16_do(loop, &divider)
+   TEST_BODY(uint16_t, UINT16_MAX, denom, divider, PRIu16, OP_U16)
+}
+
+void test_s16() {
+   int16_t denom = (int16_t)-4003;  // Prime
+   struct libdivide_s16_t divider = libdivide_s16_gen(denom);
+#define OP_S16(loop) libdivide_s16_do(loop, &divider)
+   TEST_BODY(int16_t, INT16_MAX, denom, divider, PRId16, OP_S16)
+}
+
+void test_u32() {
+   uint32_t denom = ((uint32_t)2 << 21) - 19; // Prime - see https://primes.utm.edu/lists/2small/0bit.html
+   struct libdivide_u32_t divider = libdivide_u32_gen(denom);
+#define OP_U32(loop) libdivide_u32_do(loop, &divider)
+   TEST_BODY(uint32_t, UINT32_MAX, denom, divider, PRIu32, OP_U32)
+}
+
+void test_s32() {
+   int32_t denom = -(((int32_t)2 << 21) - 55); // Prime - see https://primes.utm.edu/lists/2small/0bit.html
+   struct libdivide_s32_t divider = libdivide_s32_gen(denom);
+#define OP_S32(loop) libdivide_s32_do(loop, &divider)
+   TEST_BODY(int32_t, INT32_MAX, denom, divider, PRId32, OP_S32)
+}
+
+void test_u64() {
+   uint64_t denom = ((uint64_t)2 << 29) - 43;  // Prime - see https://primes.utm.edu/lists/2small/0bit.html
+   struct libdivide_u64_t divider = libdivide_u64_gen(denom);
+#define OP_U64(loop) libdivide_u64_do(loop, &divider)
+   TEST_BODY(uint64_t, (UINT64_MAX/2) /* For speed */, denom, divider, PRIu64, OP_U64)
+}
+
+void test_s64() {
+   int64_t denom =  -(((int64_t)2 << 29) - 121); // Prime - see https://primes.utm.edu/lists/2small/0bit.html
+   struct libdivide_s64_t divider = libdivide_s64_gen(denom);
+#define OP_S64(loop) libdivide_s64_do(loop, &divider)
+   TEST_BODY(int64_t, INT64_MAX, denom, divider, PRId64, OP_S64)
+}
+
+int main (int argc, char *argv[]) { 
+   UNUSED(argc);
+   UNUSED(argv);
+   
+   test_u16();
+   test_s16();
+   test_u32();
+   test_s32();
+   test_u64();
+   test_s64();
+}

Original file line number	Diff line number	Diff line change
`@@ -82,7 +82,8 @@`
`82`	`82`	`"xlocale": "cpp",`
`83`	`83`	`"xlocbuf": "cpp",`
`84`	`84`	`"xlocinfo": "cpp",`
`85`		`- "xlocmes": "cpp"`
	`85`	`+ "xlocmes": "cpp",`
	`86`	`+ "xmemory0": "c"`
`86`	`87`	`}`
`87`	`88`	`}`
`88`	`89`	`}`