| // 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; |
| } |