aboutsummaryrefslogtreecommitdiff
path: root/final/runtime/test/atomic/omp_atomic.c
diff options
context:
space:
mode:
Diffstat (limited to 'final/runtime/test/atomic/omp_atomic.c')
-rw-r--r--final/runtime/test/atomic/omp_atomic.c366
1 files changed, 366 insertions, 0 deletions
diff --git a/final/runtime/test/atomic/omp_atomic.c b/final/runtime/test/atomic/omp_atomic.c
new file mode 100644
index 0000000..7cdd30d
--- /dev/null
+++ b/final/runtime/test/atomic/omp_atomic.c
@@ -0,0 +1,366 @@
+// RUN: %libomp-compile-and-run
+#include <stdio.h>
+#include <math.h>
+#include "omp_testsuite.h"
+
+#define DOUBLE_DIGITS 20 /* dt^DOUBLE_DIGITS */
+#define MAX_FACTOR 10
+#define KNOWN_PRODUCT 3628800 /* 10! */
+
+int test_omp_atomic()
+{
+ int sum;
+ int diff;
+ double dsum = 0;
+ double dt = 0.5; /* base of geometric row for + and - test*/
+ double ddiff;
+ int product;
+ int x;
+ int *logics;
+ int bit_and = 1;
+ int bit_or = 0;
+ int exclusiv_bit_or = 0;
+ int j;
+ int known_sum;
+ int known_diff;
+ int known_product;
+ int result = 0;
+ int logic_and = 1;
+ int logic_or = 0;
+ double dknown_sum;
+ double rounding_error = 1.E-9;
+ double dpt, div;
+ int logicsArray[LOOPCOUNT];
+ logics = logicsArray;
+
+ sum = 0;
+ diff = 0;
+ product = 1;
+
+ // sum of integers test
+ #pragma omp parallel
+ {
+ int i;
+ #pragma omp for
+ for (i = 1; i <= LOOPCOUNT; i++) {
+ #pragma omp atomic
+ sum += i;
+ }
+
+ }
+ known_sum = (LOOPCOUNT * (LOOPCOUNT + 1)) / 2;
+ if (known_sum != sum)
+ {
+ fprintf(stderr,
+ "Error in sum with integers: Result was %d instead of %d.\n",
+ sum, known_sum);
+ result++;
+ }
+
+ // difference of integers test
+ #pragma omp parallel
+ {
+ int i;
+ #pragma omp for
+ for (i = 0; i < LOOPCOUNT; i++) {
+ #pragma omp atomic
+ diff -= i;
+ }
+ }
+ known_diff = ((LOOPCOUNT - 1) * LOOPCOUNT) / 2 * -1;
+ if (diff != known_diff)
+ {
+ fprintf (stderr,
+ "Error in difference with integers: Result was %d instead of 0.\n",
+ diff);
+ result++;
+ }
+
+ // sum of doubles test
+ dsum = 0;
+ dpt = 1;
+ for (j = 0; j < DOUBLE_DIGITS; ++j) {
+ dpt *= dt;
+ }
+ dknown_sum = (1 - dpt) / (1 -dt);
+ #pragma omp parallel
+ {
+ int i;
+ #pragma omp for
+ for (i = 0; i < DOUBLE_DIGITS; ++i) {
+ #pragma omp atomic
+ dsum += pow (dt, i);
+ }
+ }
+ if (dsum != dknown_sum && (fabs (dsum - dknown_sum) > rounding_error)) {
+ fprintf (stderr, "Error in sum with doubles: Result was %f"
+ " instead of: %f (Difference: %E)\n",
+ dsum, dknown_sum, dsum - dknown_sum);
+ result++;
+ }
+
+ // difference of doubles test
+ dpt = 1;
+ for (j = 0; j < DOUBLE_DIGITS; ++j) {
+ dpt *= dt;
+ }
+ ddiff = (1 - dpt) / (1 - dt);
+ #pragma omp parallel
+ {
+ int i;
+ #pragma omp for
+ for (i = 0; i < DOUBLE_DIGITS; ++i) {
+ #pragma omp atomic
+ ddiff -= pow (dt, i);
+ }
+ }
+ if (fabs (ddiff) > rounding_error) {
+ fprintf (stderr,
+ "Error in difference with doubles: Result was %E instead of 0.0\n",
+ ddiff);
+ result++;
+ }
+
+ // product of integers test
+ #pragma omp parallel
+ {
+ int i;
+ #pragma omp for
+ for (i = 1; i <= MAX_FACTOR; i++) {
+ #pragma omp atomic
+ product *= i;
+ }
+ }
+ known_product = KNOWN_PRODUCT;
+ if (known_product != product) {
+ fprintf (stderr,
+ "Error in product with integers: Result was %d instead of %d\n",
+ product, known_product);
+ result++;
+ }
+
+ // division of integers test
+ product = KNOWN_PRODUCT;
+ #pragma omp parallel
+ {
+ int i;
+ #pragma omp for
+ for (i = 1; i <= MAX_FACTOR; ++i) {
+ #pragma omp atomic
+ product /= i;
+ }
+ }
+ if (product != 1) {
+ fprintf (stderr,
+ "Error in product division with integers: Result was %d"
+ " instead of 1\n",
+ product);
+ result++;
+ }
+
+ // division of doubles test
+ div = 5.0E+5;
+ #pragma omp parallel
+ {
+ int i;
+ #pragma omp for
+ for (i = 1; i <= MAX_FACTOR; i++) {
+ #pragma omp atomic
+ div /= i;
+ }
+ }
+ if (fabs(div-0.137787) >= 1.0E-4 ) {
+ result++;
+ fprintf (stderr, "Error in division with double: Result was %f"
+ " instead of 0.137787\n", div);
+ }
+
+ // ++ test
+ x = 0;
+ #pragma omp parallel
+ {
+ int i;
+ #pragma omp for
+ for (i = 0; i < LOOPCOUNT; ++i) {
+ #pragma omp atomic
+ x++;
+ }
+ }
+ if (x != LOOPCOUNT) {
+ result++;
+ fprintf (stderr, "Error in ++\n");
+ }
+
+ // -- test
+ #pragma omp parallel
+ {
+ int i;
+ #pragma omp for
+ for (i = 0; i < LOOPCOUNT; ++i) {
+ #pragma omp atomic
+ x--;
+ }
+ }
+ if (x != 0) {
+ result++;
+ fprintf (stderr, "Error in --\n");
+ }
+
+ // bit-and test part 1
+ for (j = 0; j < LOOPCOUNT; ++j) {
+ logics[j] = 1;
+ }
+ bit_and = 1;
+ #pragma omp parallel
+ {
+ int i;
+ #pragma omp for
+ for (i = 0; i < LOOPCOUNT; ++i) {
+ #pragma omp atomic
+ bit_and &= logics[i];
+ }
+ }
+ if (!bit_and) {
+ result++;
+ fprintf (stderr, "Error in BIT AND part 1\n");
+ }
+
+ // bit-and test part 2
+ bit_and = 1;
+ logics[LOOPCOUNT / 2] = 0;
+ #pragma omp parallel
+ {
+ int i;
+ #pragma omp for
+ for (i = 0; i < LOOPCOUNT; ++i) {
+ #pragma omp atomic
+ bit_and &= logics[i];
+ }
+ }
+ if (bit_and) {
+ result++;
+ fprintf (stderr, "Error in BIT AND part 2\n");
+ }
+
+ // bit-or test part 1
+ for (j = 0; j < LOOPCOUNT; j++) {
+ logics[j] = 0;
+ }
+ bit_or = 0;
+ #pragma omp parallel
+ {
+ int i;
+ #pragma omp for
+ for (i = 0; i < LOOPCOUNT; ++i) {
+ #pragma omp atomic
+ bit_or |= logics[i];
+ }
+ }
+ if (bit_or) {
+ result++;
+ fprintf (stderr, "Error in BIT OR part 1\n");
+ }
+
+ // bit-or test part 2
+ bit_or = 0;
+ logics[LOOPCOUNT / 2] = 1;
+ #pragma omp parallel
+ {
+
+ int i;
+ #pragma omp for
+ for (i = 0; i < LOOPCOUNT; ++i) {
+ #pragma omp atomic
+ bit_or |= logics[i];
+ }
+ }
+ if (!bit_or) {
+ result++;
+ fprintf (stderr, "Error in BIT OR part 2\n");
+ }
+
+ // bit-xor test part 1
+ for (j = 0; j < LOOPCOUNT; j++) {
+ logics[j] = 0;
+ }
+ exclusiv_bit_or = 0;
+ #pragma omp parallel
+ {
+ int i;
+ #pragma omp for
+ for (i = 0; i < LOOPCOUNT; ++i) {
+ #pragma omp atomic
+ exclusiv_bit_or ^= logics[i];
+ }
+ }
+ if (exclusiv_bit_or) {
+ result++;
+ fprintf (stderr, "Error in EXCLUSIV BIT OR part 1\n");
+ }
+
+ // bit-xor test part 2
+ exclusiv_bit_or = 0;
+ logics[LOOPCOUNT / 2] = 1;
+ #pragma omp parallel
+ {
+ int i;
+ #pragma omp for
+ for (i = 0; i < LOOPCOUNT; ++i) {
+ #pragma omp atomic
+ exclusiv_bit_or ^= logics[i];
+ }
+
+ }
+ if (!exclusiv_bit_or) {
+ result++;
+ fprintf (stderr, "Error in EXCLUSIV BIT OR part 2\n");
+ }
+
+ // left shift test
+ x = 1;
+ #pragma omp parallel
+ {
+ int i;
+ #pragma omp for
+ for (i = 0; i < 10; ++i) {
+ #pragma omp atomic
+ x <<= 1;
+ }
+
+ }
+ if ( x != 1024) {
+ result++;
+ fprintf (stderr, "Error in <<\n");
+ x = 1024;
+ }
+
+ // right shift test
+ #pragma omp parallel
+ {
+ int i;
+ #pragma omp for
+ for (i = 0; i < 10; ++i) {
+ #pragma omp atomic
+ x >>= 1;
+ }
+ }
+ if (x != 1) {
+ result++;
+ fprintf (stderr, "Error in >>\n");
+ }
+
+ return (result == 0);
+} // test_omp_atomic()
+
+int main()
+{
+ int i;
+ int num_failed=0;
+
+ for(i = 0; i < REPETITIONS; i++) {
+ if(!test_omp_atomic()) {
+ num_failed++;
+ }
+ }
+ return num_failed;
+}
generated by cgit v1.2.3 (git 2.25.1) at 2024-04-24 22:57:22 +0000