|
111
|
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 #pragma omp atomic read
|
|
|
102 l = c[i][j][k + 2];
|
|
|
103 if (l < 2)
|
|
|
104 abort ();
|
|
|
105 }
|
|
|
106 #pragma omp atomic write
|
|
|
107 c[i][j][k] = 2;
|
|
|
108 if (i >= 4 && j < 7 && k >= 4)
|
|
|
109 {
|
|
|
110 #pragma omp atomic read
|
|
|
111 l = c[i - 2][j + 1][k - 4];
|
|
|
112 if (l < 2)
|
|
|
113 abort ();
|
|
|
114 }
|
|
|
115 if (i >= 3 && j >= 4 && k >= 2)
|
|
|
116 {
|
|
|
117 #pragma omp atomic read
|
|
|
118 l = c[i - 1][j - 2][k - 2];
|
|
|
119 if (l < 2)
|
|
|
120 abort ();
|
|
|
121 }
|
|
|
122 #pragma omp ordered depend (source)
|
|
|
123 #pragma omp atomic write
|
|
|
124 c[i][j][k] = 3;
|
|
|
125 }
|
|
|
126 #pragma omp for schedule(guided, 5) ordered (3) nowait
|
|
|
127 for (j = 0; j < N / 16 - 1; j++)
|
|
|
128 for (k = 0; k < 8; k += 2)
|
|
|
129 for (i = 3; i <= 5 + f; i++)
|
|
|
130 {
|
|
|
131 #pragma omp atomic write
|
|
|
132 g[j][k][i] = 1;
|
|
|
133 #pragma omp ordered depend(sink: j, k - 2, i - 1) \
|
|
|
134 depend(sink: j - 2, k - 2, i + 1)
|
|
|
135 #pragma omp ordered depend(sink: j - 3, k + 2, i - 2)
|
|
|
136 if (k >= 2 && i > 3)
|
|
|
137 {
|
|
|
138 #pragma omp atomic read
|
|
|
139 l = g[j][k - 2][i - 1];
|
|
|
140 if (l < 2)
|
|
|
141 abort ();
|
|
|
142 }
|
|
|
143 #pragma omp atomic write
|
|
|
144 g[j][k][i] = 2;
|
|
|
145 if (j >= 2 && k >= 2 && i < 5)
|
|
|
146 {
|
|
|
147 #pragma omp atomic read
|
|
|
148 l = g[j - 2][k - 2][i + 1];
|
|
|
149 if (l < 2)
|
|
|
150 abort ();
|
|
|
151 }
|
|
|
152 if (j >= 3 && k < N / 16 - 3 && i == 5)
|
|
|
153 {
|
|
|
154 #pragma omp atomic read
|
|
|
155 l = g[j - 3][k + 2][i - 2];
|
|
|
156 if (l < 2)
|
|
|
157 abort ();
|
|
|
158 }
|
|
|
159 #pragma omp ordered depend(source)
|
|
|
160 #pragma omp atomic write
|
|
|
161 g[j][k][i] = 3;
|
|
|
162 }
|
|
|
163 #pragma omp for collapse(2) ordered(4) lastprivate (i, j, k)
|
|
|
164 for (i = 2; i < f + 3; i++)
|
|
|
165 for (j = d + 1; j >= 0; j--)
|
|
|
166 for (k = 0; k < d; k++)
|
|
|
167 for (l = 0; l < d + 2; l++)
|
|
|
168 {
|
|
|
169 #pragma omp ordered depend (source)
|
|
|
170 #pragma omp ordered depend (sink:i - 2, j + 2, k - 2, l)
|
|
|
171 if (!e)
|
|
|
172 abort ();
|
|
|
173 }
|
|
|
174 #pragma omp single
|
|
|
175 {
|
|
|
176 if (i != 3 || j != -1 || k != 0)
|
|
|
177 abort ();
|
|
|
178 i = 8; j = 9; k = 10;
|
|
|
179 }
|
|
|
180 #pragma omp for collapse(2) ordered(4) lastprivate (i, j, k, m)
|
|
|
181 for (i = 2; i < f + 3; i++)
|
|
|
182 for (j = d + 1; j >= 0; j--)
|
|
|
183 for (k = 0; k < d + 2; k++)
|
|
|
184 for (m = 0; m < d; m++)
|
|
|
185 {
|
|
|
186 #pragma omp ordered depend (source)
|
|
|
187 #pragma omp ordered depend (sink:i - 2, j + 2, k - 2, m)
|
|
|
188 abort ();
|
|
|
189 }
|
|
|
190 #pragma omp single
|
|
|
191 if (i != 3 || j != -1 || k != 2 || m != 0)
|
|
|
192 abort ();
|
|
|
193 #pragma omp for collapse(2) ordered(4) nowait
|
|
|
194 for (i = 2; i < f + 3; i++)
|
|
|
195 for (j = d; j > 0; j--)
|
|
|
196 for (k = 0; k < d + 2; k++)
|
|
|
197 for (l = 0; l < d + 4; l++)
|
|
|
198 {
|
|
|
199 #pragma omp ordered depend (source)
|
|
|
200 #pragma omp ordered depend (sink:i - 2, j + 2, k - 2, l)
|
|
|
201 if (!e)
|
|
|
202 abort ();
|
|
|
203 }
|
|
|
204 #pragma omp for nowait
|
|
|
205 for (i = 0; i < N; i++)
|
|
|
206 if (a[i] != 3 * (i >= 1))
|
|
|
207 abort ();
|
|
|
208 #pragma omp for collapse(2) private(k) nowait
|
|
|
209 for (i = 0; i < N / 16; i++)
|
|
|
210 for (j = 0; j < 8; j++)
|
|
|
211 for (k = 0; k < 4; k++)
|
|
|
212 if (b[i][j][k] != 3 * (i >= 3 && i < N / 16 - 1 && (j & 1) == 0 && k >= 1))
|
|
|
213 abort ();
|
|
|
214 #pragma omp for collapse(3) nowait
|
|
|
215 for (i = 0; i < N / 32; i++)
|
|
|
216 for (j = 0; j < 8; j++)
|
|
|
217 for (k = 0; k < 8; k++)
|
|
|
218 if (c[i][j][k] != 3 * (i >= 2 && j >= 2 && (k & 1) == 0))
|
|
|
219 abort ();
|
|
|
220 #pragma omp for collapse(2) private(k) nowait
|
|
|
221 for (i = 0; i < N / 16; i++)
|
|
|
222 for (j = 0; j < 8; j++)
|
|
|
223 for (k = 0; k < 6; k++)
|
|
|
224 if (g[i][j][k] != 3 * (i < N / 16 - 1 && (j & 1) == 0 && k >= 3))
|
|
|
225 abort ();
|
|
|
226 }
|
|
|
227 return 0;
|
|
|
228 }
|
