gcc/testsuite/gcc.dg/di-sync-multithread.c

   1 /* { dg-do run } */
   2 /* { dg-require-effective-target sync_long_long_runtime } */
   3 /* { dg-require-effective-target pthread_h } */
   4 /* { dg-require-effective-target pthread } */
   5 /* { dg-options "-pthread -std=gnu99" } */
   6 /* { dg-additional-options "-march=pentium" { target { { i?86-*-* x86_64-*-* } && ia32 } } } */
   7
   8 /* test of long long atomic ops performed in parallel in 3 pthreads
   9    david.gilbert@linaro.org */
  10
  11 #include <pthread.h>
  12 #include <unistd.h>
  13 #ifdef _WIN32
  14 #include <windows.h>
  15 #endif
  16
  17 /*#define DEBUGIT 1 */
  18
  19 #ifdef DEBUGIT
  20 #include <stdio.h>
  21
  22 #define DOABORT(x,...) {\
  23          fprintf (stderr, x, __VA_ARGS__); fflush (stderr); abort ();\
  24          }
  25
  26 #else
  27
  28 #define DOABORT(x,...) abort ();
  29
  30 #endif
  31
  32 /* Passed to each thread to describe which bits it is going to work on.  */
  33 struct threadwork {
  34   unsigned long long count; /* incremented each time the worker loops.  */
  35   unsigned int thread;    /* ID */
  36   unsigned int addlsb;    /* 8 bit */
  37   unsigned int logic1lsb; /* 5 bit */
  38   unsigned int logic2lsb; /* 8 bit */
  39 };
  40
  41 /* The shared word where all the atomic work is done.  */
  42 static volatile long long workspace;
  43
  44 /* A shared word to tell the workers to quit when non-0.  */
  45 static long long doquit;
  46
  47 extern void abort (void);
  48
  49 /* Note this test doesn't test the return values much.  */
  50 void*
  51 worker (void* data)
  52 {
  53   struct threadwork *tw = (struct threadwork*)data;
  54   long long add1bit = 1ll << tw->addlsb;
  55   long long logic1bit = 1ll << tw->logic1lsb;
  56   long long logic2bit = 1ll << tw->logic2lsb;
  57
  58   /* Clear the bits we use.  */
  59   __sync_and_and_fetch (&workspace, ~(0xffll * add1bit));
  60   __sync_fetch_and_and (&workspace, ~(0x1fll * logic1bit));
  61   __sync_fetch_and_and (&workspace, ~(0xffll * logic2bit));
  62
  63   do
  64     {
  65       long long tmp1, tmp2, tmp3;
  66       /* OK, lets try and do some stuff to the workspace - by the end
  67          of the main loop our area should be the same as it is now - i.e. 0.  */
  68
  69       /* Push the arithmetic section up to 128 - one of the threads will
  70          case this to carry across the 32bit boundary.  */
  71       for (tmp2 = 0; tmp2 < 64; tmp2++)
  72         {
  73           /* Add 2 using the two different adds.  */
  74           tmp1 = __sync_add_and_fetch (&workspace, add1bit);
  75           tmp3 = __sync_fetch_and_add (&workspace, add1bit);
  76
  77           /* The value should be the intermediate add value in both cases.  */
  78           if ((tmp1 & (add1bit * 0xff)) != (tmp3 & (add1bit * 0xff)))
  79             DOABORT ("Mismatch of add intermediates on thread %d "
  80                         "workspace=0x%llx tmp1=0x%llx "
  81                         "tmp2=0x%llx tmp3=0x%llx\n",
  82                          tw->thread, workspace, tmp1, tmp2, tmp3);
  83         }
  84
  85       /* Set the logic bits.  */
  86       tmp2=__sync_or_and_fetch (&workspace,
  87                           0x1fll * logic1bit | 0xffll * logic2bit);
  88
  89       /* Check the logic bits are set and the arithmetic value is correct.  */
  90       if ((tmp2 & (0x1fll * logic1bit | 0xffll * logic2bit
  91                         | 0xffll * add1bit))
  92           != (0x1fll * logic1bit | 0xffll * logic2bit | 0x80ll * add1bit))
  93         DOABORT ("Midloop check failed on thread %d "
  94                         "workspace=0x%llx tmp2=0x%llx "
  95                         "masktmp2=0x%llx expected=0x%llx\n",
  96                 tw->thread, workspace, tmp2,
  97                 tmp2 & (0x1fll * logic1bit | 0xffll * logic2bit |
  98                          0xffll * add1bit),
  99                 (0x1fll * logic1bit | 0xffll * logic2bit | 0x80ll * add1bit));
 100
 101       /* Pull the arithmetic set back down to 0 - again this should cause a
 102          carry across the 32bit boundary in one thread.  */
 103
 104       for (tmp2 = 0; tmp2 < 64; tmp2++)
 105         {
 106           /* Subtract 2 using the two different subs.  */
 107           tmp1=__sync_sub_and_fetch (&workspace, add1bit);
 108           tmp3=__sync_fetch_and_sub (&workspace, add1bit);
 109
 110           /* The value should be the intermediate sub value in both cases.  */
 111           if ((tmp1 & (add1bit * 0xff)) != (tmp3 & (add1bit * 0xff)))
 112             DOABORT ("Mismatch of sub intermediates on thread %d "
 113                         "workspace=0x%llx tmp1=0x%llx "
 114                         "tmp2=0x%llx tmp3=0x%llx\n",
 115                         tw->thread, workspace, tmp1, tmp2, tmp3);
 116         }
 117
 118
 119       /* Clear the logic bits.  */
 120       __sync_fetch_and_xor (&workspace, 0x1fll * logic1bit);
 121       tmp3=__sync_and_and_fetch (&workspace, ~(0xffll * logic2bit));
 122
 123       /* The logic bits and the arithmetic bits should be zero again.  */
 124       if (tmp3 & (0x1fll * logic1bit | 0xffll * logic2bit | 0xffll * add1bit))
 125         DOABORT ("End of worker loop; bits none 0 on thread %d "
 126                         "workspace=0x%llx tmp3=0x%llx "
 127                         "mask=0x%llx maskedtmp3=0x%llx\n",
 128                 tw->thread, workspace, tmp3, (0x1fll * logic1bit |
 129                         0xffll * logic2bit | 0xffll * add1bit),
 130                 tmp3 & (0x1fll * logic1bit | 0xffll * logic2bit | 0xffll * add1bit));
 131
 132       __sync_add_and_fetch (&tw->count, 1);
 133     }
 134   while (!__sync_bool_compare_and_swap (&doquit, 1, 1));
 135
 136   pthread_exit (0);
 137 }
 138
 139 int
 140 main ()
 141 {
 142   /* We have 3 threads doing three sets of operations, an 8 bit
 143      arithmetic field, a 5 bit logic field and an 8 bit logic
 144      field (just to pack them all in).
 145
 146   6      5       4       4       3       2       1
 147   3      6       8       0       2       4       6       8       0
 148   |...,...|...,...|...,...|...,...|...,...|...,...|...,...|...,...
 149   - T0   --  T1  -- T2   --T2 --  T0  -*- T2-- T1-- T1   -***- T0-
 150    logic2  logic2  arith   log2  arith  log1 log1  arith     log1
 151
 152   */
 153   unsigned int t;
 154   long long tmp;
 155   int err;
 156
 157   struct threadwork tw[3]={
 158     { 0ll, 0, 27, 0, 56 },
 159     { 0ll, 1,  8,16, 48 },
 160     { 0ll, 2, 40,21, 35 }
 161   };
 162
 163   pthread_t threads[3];
 164
 165   __sync_lock_release (&doquit);
 166
 167   /* Get the work space into a known value - All 1's.  */
 168   __sync_lock_release (&workspace); /* Now all 0.  */
 169   tmp = __sync_val_compare_and_swap (&workspace, 0, -1ll);
 170   if (tmp!=0)
 171     DOABORT ("Initial __sync_val_compare_and_swap wasn't 0 workspace=0x%llx "
 172                 "tmp=0x%llx\n", workspace,tmp);
 173
 174   for (t = 0; t < 3; t++)
 175   {
 176     err=pthread_create (&threads[t], NULL , worker, &tw[t]);
 177     if (err) DOABORT ("pthread_create failed on thread %d with error %d\n",
 178         t, err);
 179   };
 180
 181 #ifdef _WIN32
 182   Sleep (5000);
 183 #else
 184   sleep (5);
 185 #endif
 186
 187   /* Stop please.  */
 188   __sync_lock_test_and_set (&doquit, 1ll);
 189
 190   for (t = 0; t < 3; t++)
 191     {
 192       err=pthread_join (threads[t], NULL);
 193       if (err)
 194         DOABORT ("pthread_join failed on thread %d with error %d\n", t, err);
 195     };
 196
 197   __sync_synchronize ();
 198
 199   /* OK, so all the workers have finished -
 200      the workers should have zero'd their workspace, the unused areas
 201      should still be 1.  */
 202   if (!__sync_bool_compare_and_swap (&workspace, 0x040000e0ll, 0))
 203     DOABORT ("End of run workspace mismatch, got %llx\n", workspace);
 204
 205   /* All the workers should have done some work.  */
 206   for (t = 0; t < 3; t++)
 207     {
 208       if (tw[t].count == 0) DOABORT ("Worker %d gave 0 count\n", t);
 209     };
 210
 211   return 0;
 212 }
 213