libitm/testsuite/libitm.c/priv-1.c

   1 /* Quick stress test for proxy privatization.  */
   2
   3 /* We need to use a TM method that has to enforce privatization safety
   4    explicitly.  */
   5 /* { dg-set-target-env-var ITM_DEFAULT_METHOD "ml_wt" } */
   6
   7 #include <stdlib.h>
   8 #include <stdio.h>
   9 #include <pthread.h>
  10
  11 /* Make them likely to be mapped to different orecs.  */
  12 #define ALIGN __attribute__((aligned (256)))
  13 /* Don't make these static to work around PR 68591.  */
  14 int x ALIGN;
  15 int *ptr ALIGN;
  16 int *priv_ptr ALIGN;
  17 int priv_value ALIGN;
  18 int barrier ALIGN = 0;
  19 const int iters = 100;
  20
  21 static void arrive_and_wait (int expected_value)
  22 {
  23   int now = __atomic_add_fetch (&barrier, 1, __ATOMIC_ACQ_REL);
  24   while (now < expected_value)
  25     __atomic_load (&barrier, &now, __ATOMIC_ACQUIRE);
  26 }
  27
  28 static void __attribute__((transaction_pure,noinline)) delay (int i)
  29 {
  30   for (volatile int v = 0; v < i; v++);
  31 }
  32
  33 /* This tries to catch a case in which proxy privatization safety is not
  34    ensured by privatization_user.  Specifically, it's access to the value
  35    of it's transactional snapshot of ptr must read from an uncommitted write
  36    by writer; thus, writer must still be active but must have read ptr before
  37    proxy can privatize *ptr by assigning to ptr.
  38    We try to make this interleaving more likely by delaying the commit of
  39    writer and the start of proxy.  */
  40 static void *writer (void *dummy __attribute__((unused)))
  41 {
  42   for (int i = 0; i < iters; i++)
  43     {
  44       /* Initialize state in each round.  */
  45       x = 0;
  46       ptr = &x;
  47       priv_ptr = NULL;
  48       int wrote = 1;
  49       arrive_and_wait (i * 6 + 3);
  50       /* Interference by another writer.  Has a conflict with the proxy
  51          privatizer.  */
  52       __transaction_atomic
  53         {
  54           if (ptr != NULL)
  55             *ptr = 1;
  56           else
  57             wrote = 0;
  58           delay (2000000);
  59         }
  60       arrive_and_wait (i * 6 + 6);
  61       /* If the previous transaction committed first, wrote == 1 and x == 1;
  62          otherwise, if the proxy came first, wrote == 0 and priv_value == 0.
  63        */
  64       if (wrote != priv_value)
  65         abort ();
  66     }
  67   return NULL;
  68 }
  69
  70 static void *proxy (void *dummy __attribute__((unused)))
  71 {
  72   for (int i = 0; i < iters; i++)
  73     {
  74       arrive_and_wait (i * 6 + 3);
  75       delay(1000000);
  76       __transaction_atomic
  77         {
  78           /* Hand-off to privatization-user and its read-only transaction and
  79              subsequent use of privatization.  */
  80           priv_ptr = ptr;
  81           ptr = NULL;
  82         }
  83       arrive_and_wait (i * 6 + 6);
  84     }
  85   return NULL;
  86 }
  87
  88 static void *privatization_user (void *dummy __attribute__((unused)))
  89 {
  90   for (int i = 0; i < iters; i++)
  91     {
  92       arrive_and_wait (i * 6 + 3);
  93       /* Spin until we have gotten a pointer from the proxy.  Then access
  94          the value pointed to nontransactionally.  */
  95       int *p = NULL;
  96       while (p == NULL)
  97         __transaction_atomic { p = priv_ptr; }
  98       priv_value = *p;
  99       arrive_and_wait (i * 6 + 6);
 100     }
 101   return NULL;
 102 }
 103
 104 int main()
 105 {
 106   pthread_t p[3];
 107
 108   pthread_create (p+0, NULL, writer, NULL);
 109   pthread_create (p+1, NULL, proxy, NULL);
 110   pthread_create (p+2, NULL, privatization_user, NULL);
 111
 112   for (int i = 0; i < 3; ++i)
 113     pthread_join  (p[i], NULL);
 114
 115   return 0;
 116 }