This source file includes following definitions.
- atomic_math_test
- atomic_math_test_th
- main
   1 
   2 
   3 
   4 
   5 
   6 
   7 
   8 
   9 
  10 
  11 
  12 
  13 
  14 
  15 
  16 
  17 
  18 
  19 
  20 
  21 
  22 #define OMPI_BUILDING 0
  23 #include "opal_config.h"
  24 
  25 #ifdef HAVE_PTHREAD_H
  26 #include <pthread.h>
  27 #endif
  28 #include <stdlib.h>
  29 #include <stdio.h>
  30 
  31 #include "opal/sys/atomic.h"
  32 
  33 #define TEST_REPS 500
  34 
  35 opal_atomic_int32_t val32 = 0;
  36 #if OPAL_HAVE_ATOMIC_MATH_64
  37 opal_atomic_int64_t val64 = 0;
  38 #endif
  39 opal_atomic_int_t valint = 0;
  40 
  41 static void* atomic_math_test(void* arg)
  42 {
  43     int count = *((int*) arg);
  44     int i;
  45 
  46     for (i = 0 ; i < count ; ++i) {
  47         (void)opal_atomic_add_fetch_32(&val32, 5);
  48 #if OPAL_HAVE_ATOMIC_MATH_64
  49         (void)opal_atomic_add_fetch_64(&val64, 6);
  50 #endif
  51         opal_atomic_add (&valint, 4);
  52     }
  53 
  54     return NULL;
  55 }
  56 
  57 
  58 static int
  59 atomic_math_test_th(int count, int thr_count)
  60 {
  61     int value;
  62     pthread_t *th;
  63     int tid;
  64 
  65     th = (pthread_t *) malloc(thr_count * sizeof(pthread_t));
  66     if (!th) {
  67         perror("malloc");
  68         exit(EXIT_FAILURE);
  69     }
  70 
  71     
  72 
  73 
  74 
  75 
  76     value = count;
  77     for (tid = 0; tid < thr_count; tid++) {
  78         if (pthread_create(&th[tid], NULL, atomic_math_test,
  79                            (void*) &value) != 0) {
  80             perror("pthread_create");
  81             exit(EXIT_FAILURE);
  82         }
  83     }
  84 
  85     
  86     for (tid = 0; tid < thr_count; tid++) {
  87         void *thread_return;
  88 
  89         if (pthread_join(th[tid], &thread_return) != 0) {
  90             perror("pthread_join");
  91             exit(EXIT_FAILURE);
  92         }
  93     }
  94     free(th);
  95 
  96     return 0;
  97 }
  98 
  99 
 100 int
 101 main(int argc, char *argv[])
 102 {
 103     int32_t test32;
 104 #if OPAL_HAVE_ATOMIC_MATH_64
 105     int64_t test64;
 106 #endif
 107     int ret = 77;
 108     int num_threads = 1;
 109 
 110     if (argc != 2) {
 111         printf("*** Incorrect number of arguments.  Skipping test\n");
 112         return 77;
 113     }
 114     num_threads = atoi(argv[1]);
 115 
 116     test32 = opal_atomic_add_fetch_32 (&val32, 17);
 117     if (test32 != 17 || val32 != 17) {
 118         fprintf (stderr, "error in opal_atomic_add_fetch_32. expected (17, 17), got (%d, %d)\n", test32, val32);
 119         exit(EXIT_FAILURE);
 120     }
 121 
 122     test32 = opal_atomic_fetch_add_32 (&val32, 13);
 123     if (test32 != 17 || val32 != 30) {
 124         fprintf (stderr, "error in opal_atomic_fetch_add_32. expected (17, 30), got (%d, %d)\n", test32, val32);
 125         exit(EXIT_FAILURE);
 126     }
 127 
 128 
 129 
 130     test32 = opal_atomic_and_fetch_32 (&val32, 0x18);
 131     if (test32 != 24 || val32 != 24) {
 132         fprintf (stderr, "error in opal_atomic_and_fetch_32. expected (24, 24), got (%d, %d)\n", test32, val32);
 133         exit(EXIT_FAILURE);
 134     }
 135 
 136     test32 = opal_atomic_fetch_and_32 (&val32, 0x10);
 137     if (test32 != 24 || val32 != 16) {
 138         fprintf (stderr, "error in opal_atomic_fetch_and_32. expected (24, 16), got (%d, %d)\n", test32, val32);
 139         exit(EXIT_FAILURE);
 140     }
 141 
 142 
 143 
 144     test32 = opal_atomic_or_fetch_32 (&val32, 0x03);
 145     if (test32 != 19 || val32 != 19) {
 146         fprintf (stderr, "error in opal_atomic_or_fetch_32. expected (19, 19), got (%d, %d)\n", test32, val32);
 147         exit(EXIT_FAILURE);
 148     }
 149 
 150     test32 = opal_atomic_fetch_or_32 (&val32, 0x04);
 151     if (test32 != 19 || val32 != 23) {
 152         fprintf (stderr, "error in opal_atomic_fetch_or_32. expected (19, 23), got (%d, %d)\n", test32, val32);
 153         exit(EXIT_FAILURE);
 154     }
 155 
 156 
 157     test32 = opal_atomic_xor_fetch_32 (&val32, 0x03);
 158     if (test32 != 20 || val32 != 20) {
 159         fprintf (stderr, "error in opal_atomic_xor_fetch_32. expected (20, 20), got (%d, %d)\n", test32, val32);
 160         exit(EXIT_FAILURE);
 161     }
 162 
 163     test32 = opal_atomic_fetch_xor_32 (&val32, 0x05);
 164     if (test32 != 20 || val32 != 17) {
 165         fprintf (stderr, "error in opal_atomic_fetch_xor_32. expected (20, 17), got (%d, %d)\n", test32, val32);
 166         exit(EXIT_FAILURE);
 167     }
 168 
 169 
 170 
 171     test32 = opal_atomic_sub_fetch_32 (&val32, 14);
 172     if (test32 != 3 || val32 != 3) {
 173         fprintf (stderr, "error in opal_atomic_sub_fetch_32. expected (3, 3), got (%d, %d)\n", test32, val32);
 174         exit(EXIT_FAILURE);
 175     }
 176 
 177     test32 = opal_atomic_fetch_xor_32 (&val32, 3);
 178     if (test32 != 3 || val32 != 0) {
 179         fprintf (stderr, "error in opal_atomic_fetch_sub_32. expected (3, 0), got (%d, %d)\n", test32, val32);
 180         exit(EXIT_FAILURE);
 181     }
 182 
 183 #if OPAL_HAVE_ATOMIC_MATH_64
 184     test64 = opal_atomic_add_fetch_64 (&val64, 17);
 185     if (test64 != 17 || val64 != 17) {
 186         fprintf (stderr, "error in opal_atomic_add_fetch_64. expected (17, 17), got (%" PRId64 ", %" PRId64 ")\n", test64, val64);
 187         exit(EXIT_FAILURE);
 188     }
 189 
 190     test64 = opal_atomic_fetch_add_64 (&val64, 13);
 191     if (test64 != 17 || val64 != 30) {
 192         fprintf (stderr, "error in opal_atomic_fetch_add_64. expected (17, 30), got (%" PRId64 ", %" PRId64 ")\n", test64, val64);
 193         exit(EXIT_FAILURE);
 194     }
 195 
 196 
 197 
 198     test64 = opal_atomic_and_fetch_64 (&val64, 0x18);
 199     if (test64 != 24 || val64 != 24) {
 200         fprintf (stderr, "error in opal_atomic_and_fetch_64. expected (24, 24), got (%" PRId64 ", %" PRId64 ")\n", test64, val64);
 201         exit(EXIT_FAILURE);
 202     }
 203 
 204     test64 = opal_atomic_fetch_and_64 (&val64, 0x10);
 205     if (test64 != 24 || val64 != 16) {
 206         fprintf (stderr, "error in opal_atomic_fetch_and_64. expected (24, 16), got (%" PRId64 ", %" PRId64 ")\n", test64, val64);
 207         exit(EXIT_FAILURE);
 208     }
 209 
 210 
 211 
 212     test64 = opal_atomic_or_fetch_64 (&val64, 0x03);
 213     if (test64 != 19 || val64 != 19) {
 214         fprintf (stderr, "error in opal_atomic_or_fetch_64. expected (19, 19), got (%" PRId64 ", %" PRId64 ")\n", test64, val64);
 215         exit(EXIT_FAILURE);
 216     }
 217 
 218     test64 = opal_atomic_fetch_or_64 (&val64, 0x04);
 219     if (test64 != 19 || val64 != 23) {
 220         fprintf (stderr, "error in opal_atomic_fetch_or_64. expected (19, 23), got (%" PRId64 ", %" PRId64 ")\n", test64, val64);
 221         exit(EXIT_FAILURE);
 222     }
 223 
 224 
 225     test64 = opal_atomic_xor_fetch_64 (&val64, 0x03);
 226     if (test64 != 20 || val64 != 20) {
 227         fprintf (stderr, "error in opal_atomic_xor_fetch_64. expected (20, 20), got (%" PRId64 ", %" PRId64 ")\n", test64, val64);
 228         exit(EXIT_FAILURE);
 229     }
 230 
 231     test64 = opal_atomic_fetch_xor_64 (&val64, 0x05);
 232     if (test64 != 20 || val64 != 17) {
 233         fprintf (stderr, "error in opal_atomic_fetch_xor_64. expected (20, 17), got (%" PRId64 ", %" PRId64 ")\n", test64, val64);
 234         exit(EXIT_FAILURE);
 235     }
 236 
 237 
 238 
 239     test64 = opal_atomic_sub_fetch_64 (&val64, 14);
 240     if (test64 != 3 || val64 != 3) {
 241         fprintf (stderr, "error in opal_atomic_sub_fetch_64. expected (3, 3), got (%" PRId64 ", %" PRId64 ")\n", test64, val64);
 242         exit(EXIT_FAILURE);
 243     }
 244 
 245     test64 = opal_atomic_fetch_xor_64 (&val64, 3);
 246     if (test64 != 3 || val64 != 0) {
 247         fprintf (stderr, "error in opal_atomic_fetch_sub_64. expected (3, 0), got (%" PRId64 ", %" PRId64 ")\n", test64, val64);
 248         exit(EXIT_FAILURE);
 249     }
 250 #endif
 251 
 252     ret = atomic_math_test_th(TEST_REPS, num_threads);
 253     if (ret == 77) return ret;
 254     opal_atomic_mb();
 255     if (val32 != TEST_REPS * num_threads * 5) {
 256         printf("opal_atomic_add_fetch32 failed.  Expected %d, got %d.\n",
 257                TEST_REPS * num_threads * 5, val32);
 258         ret = 1;
 259     }
 260 #if OPAL_HAVE_ATOMIC_MATH_64
 261     if (val64 != TEST_REPS * num_threads * 6) {
 262         
 263 
 264         printf("opal_atomic_add_fetch32 failed.  Expected %d, got %d.\n",
 265                TEST_REPS * num_threads * 6, (int) val64);
 266         ret = 1;
 267     }
 268 #else
 269     printf("      * skipping 64 bit tests\n");
 270 #endif
 271     if (valint != TEST_REPS * num_threads * 4) {
 272         printf("opal_atomic_add_fetch32 failed.  Expected %d, got %d.\n",
 273                TEST_REPS * num_threads * 4, valint);
 274         ret = 1;
 275     }
 276 
 277     return ret;
 278 }