Replace use of globals

Author: mborland

test/benchmark_libbid.c

@@ -3,8 +3,6 @@
 // https://www.boost.org/LICENSE_1_0.txt
 
 #define _POSIX_C_SOURCE 199309L
-#define DECIMAL_GLOBAL_ROUNDING 1
-#define DECIMAL_GLOBAL_EXCEPTION_FLAGS 1
 
 #include <stdio.h>
 #include <stdlib.h>
@@ -23,6 +21,8 @@ typedef BID_UINT128 Decimal128;
 #define K 20000000
 #define N 5
 
+uint32_t flag = 0;
+
 uint32_t random_uint32(void) 
 {
     uint32_t r = 0;
@@ -36,20 +36,20 @@ uint32_t random_uint32(void)
 
 uint64_t random_uint64(void) 
 {
-    uint32_t r = 0;
+    uint64_t r = 0;
     for (int i = 0; i < 4; i++) 
     {
         r = (r << 16) | (rand() & 0xFFFF);
     }
-    
+
     return r;
 }
 
 __attribute__ ((noinline)) void generate_vector_32(Decimal32* buffer, size_t buffer_len)
 {
     for (size_t i = 0; i < buffer_len; ++i)
     {
-        buffer[i] = bid32_from_uint32(random_uint32() % 100);
+        buffer[i] = bid32_from_uint32(random_uint32(), BID_ROUNDING_DOWN, &flag);
     }
 }
 
@@ -67,12 +67,12 @@ __attribute__ ((noinline)) void test_comparisons_32(Decimal32* data, const char*
             Decimal32 val1 = data[k];
             Decimal32 val2 = data[k + 1];
 
-            s += (size_t)bid32_quiet_less(val1, val2);
-            s += (size_t)bid32_quiet_less_equal(val1, val2);
-            s += (size_t)bid32_quiet_greater(val1, val2);
-            s += (size_t)bid32_quiet_greater_equal(val1, val2);
-            s += (size_t)bid32_quiet_equal(val1, val2);
-            s += (size_t)bid32_quiet_not_equal(val1, val2);
+            s += (size_t)bid32_quiet_less(val1, val2, &flag);
+            s += (size_t)bid32_quiet_less_equal(val1, val2, &flag);
+            s += (size_t)bid32_quiet_greater(val1, val2, &flag);
+            s += (size_t)bid32_quiet_greater_equal(val1, val2, &flag);
+            s += (size_t)bid32_quiet_equal(val1, val2, &flag);
+            s += (size_t)bid32_quiet_not_equal(val1, val2, &flag);
         }
     }
 
@@ -86,7 +86,7 @@ __attribute__ ((noinline)) void generate_vector_64(Decimal64* buffer, size_t buf
 {
     for (size_t i = 0; i < buffer_len; ++i)
     {
-        buffer[i] = bid64_from_uint64(random_uint64() % 10000);
+        buffer[i] = bid64_from_uint64(random_uint64(), BID_ROUNDING_DOWN, &flag);
     }
 }
 
@@ -104,12 +104,12 @@ __attribute__ ((noinline)) void test_comparisons_64(Decimal64* data, const char*
             Decimal64 val1 = data[k];
             Decimal64 val2 = data[k + 1];
 
-            s += (size_t)bid64_quiet_less(val1, val2);
-            s += (size_t)bid64_quiet_less_equal(val1, val2);
-            s += (size_t)bid64_quiet_greater(val1, val2);
-            s += (size_t)bid64_quiet_greater_equal(val1, val2);
-            s += (size_t)bid64_quiet_equal(val1, val2);
-            s += (size_t)bid64_quiet_not_equal(val1, val2);
+            s += (size_t)bid64_quiet_less(val1, val2, &flag);
+            s += (size_t)bid64_quiet_less_equal(val1, val2, &flag);
+            s += (size_t)bid64_quiet_greater(val1, val2, &flag);
+            s += (size_t)bid64_quiet_greater_equal(val1, val2, &flag);
+            s += (size_t)bid64_quiet_equal(val1, val2, &flag);
+            s += (size_t)bid64_quiet_not_equal(val1, val2, &flag);
         }
     }
 
@@ -125,7 +125,7 @@ __attribute__ ((__noinline__)) void generate_vector_128(Decimal128* buffer, size
     size_t i = 0;
     while (i < buffer_len)
     {
-        buffer[i] = bid128_from_uint64(random_uint64() % 100);
+        buffer[i] = bid128_from_uint64(random_uint64());
         ++i;
     }
 }
@@ -144,12 +144,12 @@ __attribute__ ((__noinline__)) void test_comparisons_128(Decimal128* data, const
             Decimal128 val1 = data[k];
             Decimal128 val2 = data[k + 1];
 
-            s += (size_t)bid128_quiet_less(val1, val2);
-            s += (size_t)bid128_quiet_less_equal(val1, val2);
-            s += (size_t)bid128_quiet_greater(val1, val2);
-            s += (size_t)bid128_quiet_greater_equal(val1, val2);
-            s += (size_t)bid128_quiet_equal(val1, val2);
-            s += (size_t)bid128_quiet_not_equal(val1, val2);
+            s += (size_t)bid128_quiet_less(val1, val2, &flag);
+            s += (size_t)bid128_quiet_less_equal(val1, val2, &flag);
+            s += (size_t)bid128_quiet_greater(val1, val2, &flag);
+            s += (size_t)bid128_quiet_greater_equal(val1, val2, &flag);
+            s += (size_t)bid128_quiet_equal(val1, val2, &flag);
+            s += (size_t)bid128_quiet_not_equal(val1, val2, &flag);
         }
     }
 
@@ -164,21 +164,21 @@ typedef Decimal32 (*operation_32)(Decimal32, Decimal32);
 
 __attribute__ ((noinline)) Decimal32 add_32(Decimal32 a, Decimal32 b)
 {
-    return bid32_add(a, b);
+    return bid32_add(a, b, BID_ROUNDING_DOWN, &flag);
 }
 __attribute__ ((noinline)) Decimal32 sub_32(Decimal32 a, Decimal32 b)
 {
-    return bid32_sub(a, b);
+    return bid32_sub(a, b, BID_ROUNDING_DOWN, &flag);
 }
 
 __attribute__ ((noinline)) Decimal32 mul_32(Decimal32 a, Decimal32 b)
 {
-    return bid32_mul(a, b);
+    return bid32_mul(a, b, BID_ROUNDING_DOWN, &flag);
 }
 
 __attribute__ ((noinline)) Decimal32 div_32(Decimal32 a, Decimal32 b)
 {
-    return bid32_div(a, b);
+    return bid32_div(a, b, BID_ROUNDING_DOWN, &flag);
 }
 
 __attribute__ ((noinline)) void test_two_element_operation_32(Decimal32* data, operation_32 op, const char* label, const char* op_label)
@@ -195,7 +195,7 @@ __attribute__ ((noinline)) void test_two_element_operation_32(Decimal32* data, o
             Decimal32 val1 = data[k];
             Decimal32 val2 = data[k + 1];
 
-            s += (size_t)bid32_to_int32_int(op(val1, val2));
+            s += (size_t)bid32_to_int32_int(op(val1, val2), &flag);
         }
     }
 
@@ -209,22 +209,22 @@ typedef Decimal64 (*operation_64)(Decimal64, Decimal64);
 
 __attribute__ ((noinline)) Decimal64 add_64(Decimal64 a, Decimal64 b)
 {
-    return bid64_add(a, b);
+    return bid64_add(a, b, BID_ROUNDING_DOWN, &flag);
 }
 
 __attribute__ ((noinline)) Decimal64 sub_64(Decimal64 a, Decimal64 b)
 {
-    return bid64_sub(a, b);
+    return bid64_sub(a, b, BID_ROUNDING_DOWN, &flag);
 }
 
 __attribute__ ((noinline)) Decimal64 mul_64(Decimal64 a, Decimal64 b)
 {
-    return bid64_mul(a, b);
+    return bid64_mul(a, b, BID_ROUNDING_DOWN, &flag);
 }
 
 __attribute__ ((noinline)) Decimal64 div_64(Decimal64 a, Decimal64 b)
 {
-    return bid64_div(a, b);
+    return bid64_div(a, b, BID_ROUNDING_DOWN, &flag);
 }
 
 __attribute__ ((noinline)) void test_two_element_operation_64(Decimal64* data, operation_64 op, const char* label, const char* op_label)
@@ -241,7 +241,7 @@ __attribute__ ((noinline)) void test_two_element_operation_64(Decimal64* data, o
             Decimal64 val1 = data[k];
             Decimal64 val2 = data[k + 1];
 
-            s += (size_t)bid64_to_int64_int(op(val1, val2));
+            s += (size_t)bid64_to_int64_int(op(val1, val2), &flag);
         }
     }
 
@@ -256,22 +256,22 @@ typedef Decimal128 (*operation_128)(Decimal128, Decimal128);
 
 __attribute__ ((__noinline__)) Decimal128 add_128(Decimal128 a, Decimal128 b)
 {
-    return bid128_add(a, b);
+    return bid128_add(a, b, BID_ROUNDING_DOWN, &flag);
 }
 
 __attribute__ ((__noinline__)) Decimal128 sub_128(Decimal128 a, Decimal128 b)
 {
-    return bid128_sub(a, b);
+    return bid128_sub(a, b, BID_ROUNDING_DOWN, &flag);
 }
 
 __attribute__ ((__noinline__)) Decimal128 mul_128(Decimal128 a, Decimal128 b)
 {
-    return bid128_mul(a, b);
+    return bid128_mul(a, b, BID_ROUNDING_DOWN, &flag);
 }
 
 __attribute__ ((__noinline__)) Decimal128 div_128(Decimal128 a, Decimal128 b)
 {
-    return bid128_div(a, b);
+    return bid128_div(a, b, BID_ROUNDING_DOWN, &flag);
 }
 
 __attribute__ ((__noinline__)) void test_two_element_operation_128(Decimal128* data, operation_128 op, const char* label, const char* op_label)
@@ -288,7 +288,7 @@ __attribute__ ((__noinline__)) void test_two_element_operation_128(Decimal128* d
             Decimal128 val1 = data[k];
             Decimal128 val2 = data[k + 1];
 
-            s += (size_t)bid128_to_int64_int(op(val1, val2));
+            s += (size_t)bid128_to_int64_int(op(val1, val2), &flag);
         }
     }