libgomp/testsuite/libgomp.c/doacross-3.c

   1 extern void abort (void);
   2
   3 #define N 256
   4 int a[N], b[N / 16][8][4], c[N / 32][8][8], g[N / 16][8][6];
   5 volatile int d, e;
   6 volatile unsigned long long f;
   7
   8 int
   9 main ()
  10 {
  11   unsigned long long i;
  12   int j, k, l, m;
  13   #pragma omp parallel private (l)
  14   {
  15     #pragma omp for schedule(guided, 3) ordered (1) nowait
  16     for (i = 1; i < N + f; i++)
  17       {
  18         #pragma omp atomic write
  19         a[i] = 1;
  20         #pragma omp ordered depend(sink: i - 1)
  21         if (i > 1)
  22           {
  23             #pragma omp atomic read
  24             l = a[i - 1];
  25             if (l < 2)
  26               abort ();
  27           }
  28         #pragma omp atomic write
  29         a[i] = 2;
  30         if (i < N - 1)
  31           {
  32             #pragma omp atomic read
  33             l = a[i + 1];
  34             if (l == 3)
  35               abort ();
  36           }
  37         #pragma omp ordered depend(source)
  38         #pragma omp atomic write
  39         a[i] = 3;
  40       }
  41     #pragma omp for schedule(guided) ordered (3) nowait
  42     for (i = 3; i < N / 16 - 1 + f; i++)
  43       for (j = 0; j < 8; j += 2)
  44         for (k = 1; k <= 3; k++)
  45           {
  46             #pragma omp atomic write
  47             b[i][j][k] = 1;
  48             #pragma omp ordered depend(sink: i, j - 2, k - 1) \
  49                                 depend(sink: i - 2, j - 2, k + 1)
  50             #pragma omp ordered depend(sink: i - 3, j + 2, k - 2)
  51             if (j >= 2 && k > 1)
  52               {
  53                 #pragma omp atomic read
  54                 l = b[i][j - 2][k - 1];
  55                 if (l < 2)
  56                   abort ();
  57               }
  58             #pragma omp atomic write
  59             b[i][j][k] = 2;
  60             if (i >= 5 && j >= 2 && k < 3)
  61               {
  62                 #pragma omp atomic read
  63                 l = b[i - 2][j - 2][k + 1];
  64                 if (l < 2)
  65                   abort ();
  66               }
  67             if (i >= 6 && j < N / 16 - 3 && k == 3)
  68               {
  69                 #pragma omp atomic read
  70                 l = b[i - 3][j + 2][k - 2];
  71                 if (l < 2)
  72                   abort ();
  73               }
  74             #pragma omp ordered depend(source)
  75             #pragma omp atomic write
  76             b[i][j][k] = 3;
  77           }
  78 #define A(n) int n;
  79 #define B(n) A(n##0) A(n##1) A(n##2) A(n##3)
  80 #define C(n) B(n##0) B(n##1) B(n##2) B(n##3)
  81 #define D(n) C(n##0) C(n##1) C(n##2) C(n##3)
  82     D(m)
  83 #undef A
  84     #pragma omp for collapse (2) ordered(61) schedule(guided, 15)
  85     for (i = 2; i < N / 32 + f; i++)
  86       for (j = 7; j > 1; j--)
  87         for (k = 6; k >= 0; k -= 2)
  88 #define A(n) for (n = 4; n < 5; n++)
  89           D(m)
  90 #undef A
  91             {
  92               #pragma omp atomic write
  93               c[i][j][k] = 1;
  94 #define A(n) ,n
  95 #define E(n) C(n##0) C(n##1) C(n##2) B(n##30) B(n##31) A(n##320) A(n##321)
  96               #pragma omp ordered depend (sink: i, j, k + 2 E(m)) \
  97                                   depend (sink:i - 2, j + 1, k - 4 E(m)) \
  98                                   depend(sink: i - 1, j - 2, k - 2 E(m))
  99               if (k <= 4)
 100                 {
 101                   l = c[i][j][k + 2];
 102                   if (l < 2)
 103                     abort ();
 104                 }
 105               #pragma omp atomic write
 106               c[i][j][k] = 2;
 107               if (i >= 4 && j < 7 && k >= 4)
 108                 {
 109                   l = c[i - 2][j + 1][k - 4];
 110                   if (l < 2)
 111                     abort ();
 112                 }
 113               if (i >= 3 && j >= 4 && k >= 2)
 114                 {
 115                   l = c[i - 1][j - 2][k - 2];
 116                   if (l < 2)
 117                     abort ();
 118                 }
 119               #pragma omp ordered depend (source)
 120               #pragma omp atomic write
 121               c[i][j][k] = 3;
 122             }
 123     #pragma omp for schedule(guided, 5) ordered (3) nowait
 124     for (j = 0; j < N / 16 - 1; j++)
 125       for (k = 0; k < 8; k += 2)
 126         for (i = 3; i <= 5 + f; i++)
 127           {
 128             #pragma omp atomic write
 129             g[j][k][i] = 1;
 130             #pragma omp ordered depend(sink: j, k - 2, i - 1) \
 131                                 depend(sink: j - 2, k - 2, i + 1)
 132             #pragma omp ordered depend(sink: j - 3, k + 2, i - 2)
 133             if (k >= 2 && i > 3)
 134               {
 135                 #pragma omp atomic read
 136                 l = g[j][k - 2][i - 1];
 137                 if (l < 2)
 138                   abort ();
 139               }
 140             #pragma omp atomic write
 141             g[j][k][i] = 2;
 142             if (j >= 2 && k >= 2 && i < 5)
 143               {
 144                 #pragma omp atomic read
 145                 l = g[j - 2][k - 2][i + 1];
 146                 if (l < 2)
 147                   abort ();
 148               }
 149             if (j >= 3 && k < N / 16 - 3 && i == 5)
 150               {
 151                 #pragma omp atomic read
 152                 l = g[j - 3][k + 2][i - 2];
 153                 if (l < 2)
 154                   abort ();
 155               }
 156             #pragma omp ordered depend(source)
 157             #pragma omp atomic write
 158             g[j][k][i] = 3;
 159           }
 160     #pragma omp for collapse(2) ordered(4) lastprivate (i, j, k)
 161     for (i = 2; i < f + 3; i++)
 162       for (j = d + 1; j >= 0; j--)
 163         for (k = 0; k < d; k++)
 164           for (l = 0; l < d + 2; l++)
 165             {
 166               #pragma omp ordered depend (source)
 167               #pragma omp ordered depend (sink:i - 2, j + 2, k - 2, l)
 168               if (!e)
 169                 abort ();
 170             }
 171     #pragma omp single
 172     {
 173       if (i != 3 || j != -1 || k != 0)
 174         abort ();
 175       i = 8; j = 9; k = 10;
 176     }
 177     #pragma omp for collapse(2) ordered(4) lastprivate (i, j, k, m)
 178     for (i = 2; i < f + 3; i++)
 179       for (j = d + 1; j >= 0; j--)
 180         for (k = 0; k < d + 2; k++)
 181           for (m = 0; m < d; m++)
 182             {
 183               #pragma omp ordered depend (source)
 184               #pragma omp ordered depend (sink:i - 2, j + 2, k - 2, m)
 185               abort ();
 186             }
 187     #pragma omp single
 188     if (i != 3 || j != -1 || k != 2 || m != 0)
 189       abort ();
 190     #pragma omp for collapse(2) ordered(4) nowait
 191     for (i = 2; i < f + 3; i++)
 192       for (j = d; j > 0; j--)
 193         for (k = 0; k < d + 2; k++)
 194           for (l = 0; l < d + 4; l++)
 195             {
 196               #pragma omp ordered depend (source)
 197               #pragma omp ordered depend (sink:i - 2, j + 2, k - 2, l)
 198               if (!e)
 199                 abort ();
 200             }
 201     #pragma omp for nowait
 202     for (i = 0; i < N; i++)
 203       if (a[i] != 3 * (i >= 1))
 204         abort ();
 205     #pragma omp for collapse(2) private(k) nowait
 206     for (i = 0; i < N / 16; i++)
 207       for (j = 0; j < 8; j++)
 208         for (k = 0; k < 4; k++)
 209           if (b[i][j][k] != 3 * (i >= 3 && i < N / 16 - 1 && (j & 1) == 0 && k >= 1))
 210             abort ();
 211     #pragma omp for collapse(3) nowait
 212     for (i = 0; i < N / 32; i++)
 213       for (j = 0; j < 8; j++)
 214         for (k = 0; k < 8; k++)
 215           if (c[i][j][k] != 3 * (i >= 2 && j >= 2 && (k & 1) == 0))
 216             abort ();
 217     #pragma omp for collapse(2) private(k) nowait
 218     for (i = 0; i < N / 16; i++)
 219       for (j = 0; j < 8; j++)
 220         for (k = 0; k < 6; k++)
 221           if (g[i][j][k] != 3 * (i < N / 16 - 1 && (j & 1) == 0 && k >= 3))
 222             abort ();
 223   }
 224   return 0;
 225 }