libgomp/testsuite/libgomp.c++/for-24.C

   1 // { dg-do run }
   2 // { dg-additional-options "-std=c++17" }
   3
   4 typedef __PTRDIFF_TYPE__ ptrdiff_t;
   5 extern "C" void abort ();
   6
   7 namespace std {
   8   template<typename T> struct tuple_size;
   9   template<int, typename> struct tuple_element;
  10 }
  11
  12 #pragma omp declare target
  13 template <typename T>
  14 class I
  15 {
  16 public:
  17   typedef ptrdiff_t difference_type;
  18   I ();
  19   ~I ();
  20   I (T *);
  21   I (const I &);
  22   T &operator * ();
  23   T *operator -> ();
  24   T &operator [] (const difference_type &) const;
  25   I &operator = (const I &);
  26   I &operator ++ ();
  27   I operator ++ (int);
  28   I &operator -- ();
  29   I operator -- (int);
  30   I &operator += (const difference_type &);
  31   I &operator -= (const difference_type &);
  32   I operator + (const difference_type &) const;
  33   I operator - (const difference_type &) const;
  34   template <typename S> friend bool operator == (I<S> &, I<S> &);
  35   template <typename S> friend bool operator == (const I<S> &, const I<S> &);
  36   template <typename S> friend bool operator < (I<S> &, I<S> &);
  37   template <typename S> friend bool operator < (const I<S> &, const I<S> &);
  38   template <typename S> friend bool operator <= (I<S> &, I<S> &);
  39   template <typename S> friend bool operator <= (const I<S> &, const I<S> &);
  40   template <typename S> friend bool operator > (I<S> &, I<S> &);
  41   template <typename S> friend bool operator > (const I<S> &, const I<S> &);
  42   template <typename S> friend bool operator >= (I<S> &, I<S> &);
  43   template <typename S> friend bool operator >= (const I<S> &, const I<S> &);
  44   template <typename S> friend typename I<S>::difference_type operator - (I<S> &, I<S> &);
  45   template <typename S> friend typename I<S>::difference_type operator - (const I<S> &, const I<S> &);
  46   template <typename S> friend I<S> operator + (typename I<S>::difference_type , const I<S> &);
  47 private:
  48   T *p;
  49 };
  50 template <typename T> I<T>::I () : p (0) {}
  51 template <typename T> I<T>::~I () {}
  52 template <typename T> I<T>::I (T *x) : p (x) {}
  53 template <typename T> I<T>::I (const I &x) : p (x.p) {}
  54 template <typename T> T &I<T>::operator * () { return *p; }
  55 template <typename T> T *I<T>::operator -> () { return p; }
  56 template <typename T> T &I<T>::operator [] (const difference_type &x) const { return p[x]; }
  57 template <typename T> I<T> &I<T>::operator = (const I &x) { p = x.p; return *this; }
  58 template <typename T> I<T> &I<T>::operator ++ () { ++p; return *this; }
  59 template <typename T> I<T> I<T>::operator ++ (int) { return I (p++); }
  60 template <typename T> I<T> &I<T>::operator -- () { --p; return *this; }
  61 template <typename T> I<T> I<T>::operator -- (int) { return I (p--); }
  62 template <typename T> I<T> &I<T>::operator += (const difference_type &x) { p += x; return *this; }
  63 template <typename T> I<T> &I<T>::operator -= (const difference_type &x) { p -= x; return *this; }
  64 template <typename T> I<T> I<T>::operator + (const difference_type &x) const { return I (p + x); }
  65 template <typename T> I<T> I<T>::operator - (const difference_type &x) const { return I (p - x); }
  66 template <typename T> bool operator == (I<T> &x, I<T> &y) { return x.p == y.p; }
  67 template <typename T> bool operator == (const I<T> &x, const I<T> &y) { return x.p == y.p; }
  68 template <typename T> bool operator != (I<T> &x, I<T> &y) { return !(x == y); }
  69 template <typename T> bool operator != (const I<T> &x, const I<T> &y) { return !(x == y); }
  70 template <typename T> bool operator < (I<T> &x, I<T> &y) { return x.p < y.p; }
  71 template <typename T> bool operator < (const I<T> &x, const I<T> &y) { return x.p < y.p; }
  72 template <typename T> bool operator <= (I<T> &x, I<T> &y) { return x.p <= y.p; }
  73 template <typename T> bool operator <= (const I<T> &x, const I<T> &y) { return x.p <= y.p; }
  74 template <typename T> bool operator > (I<T> &x, I<T> &y) { return x.p > y.p; }
  75 template <typename T> bool operator > (const I<T> &x, const I<T> &y) { return x.p > y.p; }
  76 template <typename T> bool operator >= (I<T> &x, I<T> &y) { return x.p >= y.p; }
  77 template <typename T> bool operator >= (const I<T> &x, const I<T> &y) { return x.p >= y.p; }
  78 template <typename T> typename I<T>::difference_type operator - (I<T> &x, I<T> &y) { return x.p - y.p; }
  79 template <typename T> typename I<T>::difference_type operator - (const I<T> &x, const I<T> &y) { return x.p - y.p; }
  80 template <typename T> I<T> operator + (typename I<T>::difference_type x, const I<T> &y) { return I<T> (x + y.p); }
  81
  82 template <typename T>
  83 class J
  84 {
  85 public:
  86   J(const I<T> &x, const I<T> &y) : b (x), e (y) {}
  87   const I<T> &begin ();
  88   const I<T> &end ();
  89 private:
  90   I<T> b, e;
  91 };
  92
  93 template <typename T> const I<T> &J<T>::begin () { return b; }
  94 template <typename T> const I<T> &J<T>::end () { return e; }
  95
  96 struct K
  97 {
  98   template <int N> int &get () { if (N == 0) return c; else if (N == 1) return b; return a; }
  99   int a, b, c;
 100 };
 101
 102 template <> struct std::tuple_size<K> { static constexpr int value = 3; };
 103 template <int N> struct std::tuple_element<N, K> { using type = int; };
 104
 105 struct L
 106 {
 107   int a, b, c;
 108 };
 109
 110 int a[2000];
 111 long b[40];
 112 short c[50];
 113 int d[1024];
 114 K e[1089];
 115 L f[1093];
 116
 117 int results[2000];
 118
 119 template <typename T>
 120 void
 121 baz (I<T> &i)
 122 {
 123   if (*i < 0 || *i >= 2000)
 124     abort ();
 125   results[*i]++;
 126 }
 127
 128 void
 129 baz (int i)
 130 {
 131   if (i < 0 || i >= 2000)
 132     abort ();
 133   results[i]++;
 134 }
 135
 136 void
 137 f1 ()
 138 {
 139 #pragma omp distribute parallel for default(none) shared(a)
 140   for (auto i : a)
 141     baz (i);
 142 }
 143
 144 void
 145 f2 ()
 146 {
 147 #pragma omp distribute parallel for default(none) shared(a)
 148   for (auto &i : a)
 149     if (&i != &a[i])
 150       abort ();
 151     else
 152       baz (i);
 153 }
 154
 155 void
 156 f3 ()
 157 {
 158 #pragma omp distribute parallel for collapse(3) default(none) shared(b, c)
 159   for (auto &i : b)
 160     for (int j = 9; j < 10; j++)
 161       for (auto k : c)
 162         if (&i != &b[i] || i < 0 || i >= 40 || j != 9 || k < 0 || k >= 50)
 163           abort ();
 164         else
 165           baz (i * 50 + k);
 166 }
 167
 168 void
 169 f4 (J<int> j)
 170 {
 171 #pragma omp distribute parallel for default(none) shared(j, a)
 172   for (auto &i : j)
 173     if (&i != &a[i])
 174       abort ();
 175     else
 176       baz (i);
 177 }
 178
 179 void
 180 f5 ()
 181 {
 182 #pragma omp distribute parallel for simd default(none) shared(d, results)
 183   for (auto i : d)
 184     results[i % 1024] += 2 * ((unsigned) i >> 10) + 1;
 185 }
 186
 187 void
 188 f6 (J<K> j)
 189 {
 190 #pragma omp distribute parallel for default(none) shared(j, e)
 191   for (auto & [k, l, m] : j)
 192     if (&k != &e[m].c || &l != &e[m].b || &m != &e[m].a || k != m * 3 || l != m * 2)
 193       abort ();
 194     else
 195       baz (m);
 196 }
 197
 198 void
 199 f7 (J<L> j)
 200 {
 201 #pragma omp distribute parallel for default(none) shared(j, f)
 202   for (auto & [k, l, m] : j)
 203     if (&k != &f[k].a || &l != &f[k].b || &m != &f[k].c || l != k * 4 || m != k * 5)
 204       abort ();
 205     else
 206       baz (k);
 207 }
 208
 209 void
 210 f8 (J<K> j)
 211 {
 212 #pragma omp distribute parallel for default(none) shared(j)
 213   for (auto [k, l, m] : j)
 214     if (k != m * 3 || l != m * 2)
 215       abort ();
 216     else
 217       baz (m);
 218 }
 219
 220 void
 221 f9 (J<L> j)
 222 {
 223 #pragma omp distribute parallel for default(none) shared(j)
 224   for (auto [k, l, m] : j)
 225     if (l != k * 4 || m != k * 5)
 226       abort ();
 227     else
 228       baz (k);
 229 }
 230
 231 template <int N>
 232 void
 233 f10 ()
 234 {
 235 #pragma omp distribute parallel for default(none) shared(a)
 236   for (auto i : a)
 237     baz (i);
 238 }
 239
 240 template <int N>
 241 void
 242 f11 ()
 243 {
 244 #pragma omp distribute parallel for default(none) shared(a)
 245   for (auto &i : a)
 246     if (&i != &a[i])
 247       abort ();
 248     else
 249       baz (i);
 250 }
 251
 252 template <int N>
 253 void
 254 f12 ()
 255 {
 256 #pragma omp distribute parallel for collapse(3) default(none) shared(a, b, c)
 257   for (auto &i : b)
 258     for (I<int> j = I<int> (&a[9]); j < I<int> (&a[10]); j++)
 259       for (auto k : c)
 260         if (&i != &b[i] || i < 0 || i >= 40 || *j != 9 || k < 0 || k >= 50)
 261           abort ();
 262         else
 263           baz (i * 50 + k);
 264 }
 265
 266 template <typename T>
 267 void
 268 f13 (J<T> j)
 269 {
 270 #pragma omp distribute parallel for default(none) shared(j, a)
 271   for (auto &i : j)
 272     if (&i != &a[i])
 273       abort ();
 274     else
 275       baz (i);
 276 }
 277
 278 template <int N>
 279 void
 280 f14 ()
 281 {
 282 #pragma omp distribute parallel for simd default(none) shared(d, results)
 283   for (auto i : d)
 284     results[i % N] += 2 * ((unsigned) i >> 10) + 1;
 285 }
 286
 287 template <typename T>
 288 void
 289 f15 (J<T> j)
 290 {
 291 #pragma omp distribute parallel for default(none) shared(j, e)
 292   for (auto & [k, l, m] : j)
 293     if (&k != &e[m].c || &l != &e[m].b || &m != &e[m].a || k != m * 3 || l != m * 2)
 294       abort ();
 295     else
 296       baz (m);
 297 }
 298
 299 template <typename T>
 300 void
 301 f16 (J<T> j)
 302 {
 303 #pragma omp distribute parallel for default(none) shared(j, f)
 304   for (auto & [k, l, m] : j)
 305     if (&k != &f[k].a || &l != &f[k].b || &m != &f[k].c || l != k * 4 || m != k * 5)
 306       abort ();
 307     else
 308       baz (k);
 309 }
 310
 311 template <int N>
 312 void
 313 f17 (J<K> j)
 314 {
 315 #pragma omp distribute parallel for default(none) shared(j)
 316   for (auto [k, l, m] : j)
 317     if (k != m * 3 || l != m * 2)
 318       abort ();
 319     else
 320       baz (m);
 321 }
 322
 323 template <int N>
 324 void
 325 f18 (J<L> j)
 326 {
 327 #pragma omp distribute parallel for default(none) shared(j)
 328   for (auto [k, l, m] : j)
 329     if (l != k * 4 || m != k * 5)
 330       abort ();
 331     else
 332       baz (k);
 333 }
 334 #pragma omp end declare target
 335
 336 #define check(expr) \
 337   for (int i = 0; i < 2000; i++)                        \
 338     if (expr)                                           \
 339       {                                                 \
 340         if (results[i] != 1)                            \
 341           abort ();                                     \
 342         results[i] = 0;                                 \
 343       }                                                 \
 344     else if (results[i])                                \
 345       abort ()
 346
 347 int
 348 main ()
 349 {
 350   for (int i = 0; i < 2000; i++)
 351     a[i] = i;
 352   for (int i = 0; i < 40; i++)
 353     b[i] = i;
 354   for (int i = 0; i < 50; i++)
 355     c[i] = i;
 356   for (int i = 0; i < 1024; i++)
 357     d[i] = i;
 358   for (int i = 0; i < 1089; i++)
 359     {
 360       e[i].a = i;
 361       e[i].b = 2 * i;
 362       e[i].c = 3 * i;
 363     }
 364   for (int i = 0; i < 1093; i++)
 365     {
 366       f[i].a = i;
 367       f[i].b = 4 * i;
 368       f[i].c = 5 * i;
 369     }
 370   #pragma omp target update to (a, b, c, d, e, f)
 371   #pragma omp target teams map (always, tofrom: results)
 372   f1 ();
 373   check (1);
 374   #pragma omp target teams map (always, tofrom: results)
 375   f2 ();
 376   check (1);
 377   #pragma omp target teams map (always, tofrom: results)
 378   f3 ();
 379   check (1);
 380   #pragma omp target teams map (always, tofrom: results)
 381   f4 (J<int> (&a[14], &a[1803]));
 382   check (i >= 14 && i < 1803);
 383   #pragma omp target teams map (always, tofrom: results)
 384   f5 ();
 385   check (i >= 0 && i < 1024);
 386   #pragma omp target teams map (always, tofrom: results)
 387   f6 (J<K> (&e[19], &e[1029]));
 388   check (i >= 19 && i < 1029);
 389   #pragma omp target teams map (always, tofrom: results)
 390   f7 (J<L> (&f[15], &f[1091]));
 391   check (i >= 15 && i < 1091);
 392   #pragma omp target teams map (always, tofrom: results)
 393   f8 (J<K> (&e[27], &e[1037]));
 394   check (i >= 27 && i < 1037);
 395   #pragma omp target teams map (always, tofrom: results)
 396   f9 (J<L> (&f[1], &f[1012]));
 397   check (i >= 1 && i < 1012);
 398   #pragma omp target teams map (always, tofrom: results)
 399   f10 <0> ();
 400   check (1);
 401   #pragma omp target teams map (always, tofrom: results)
 402   f11 <1> ();
 403   check (1);
 404   #pragma omp target teams map (always, tofrom: results)
 405   f12 <2> ();
 406   check (1);
 407   #pragma omp target teams map (always, tofrom: results)
 408   f13 (J<int> (&a[24], &a[1703]));
 409   check (i >= 24 && i < 1703);
 410   #pragma omp target teams map (always, tofrom: results)
 411   f14 <1024> ();
 412   check (i >= 0 && i < 1024);
 413   #pragma omp target teams map (always, tofrom: results)
 414   f15 (J<K> (&e[39], &e[929]));
 415   check (i >= 39 && i < 929);
 416   #pragma omp target teams map (always, tofrom: results)
 417   f16 (J<L> (&f[17], &f[1071]));
 418   check (i >= 17 && i < 1071);
 419   #pragma omp target teams map (always, tofrom: results)
 420   f17 <3> (J<K> (&e[7], &e[1017]));
 421   check (i >= 7 && i < 1017);
 422   #pragma omp target teams map (always, tofrom: results)
 423   f18 <5> (J<L> (&f[121], &f[1010]));
 424   check (i >= 121 && i < 1010);
 425 }