libgomp/testsuite/libgomp.c++/ctor-13.C

   1 // { dg-do run }
   2
   3 #include <omp.h>
   4 #include <assert.h>
   5
   6 struct B
   7 {
   8   static int ic, dc, xc, ac, cc;
   9
  10   B();
  11   B(const B &);
  12   ~B();
  13   B& operator=(const B &);
  14   void doit();
  15   static void clear();
  16 };
  17
  18 int B::ic;
  19 int B::dc;
  20 int B::xc;
  21 int B::cc;
  22 int B::ac;
  23
  24 B::B()
  25 {
  26   #pragma omp atomic
  27     ic++;
  28 }
  29
  30 B::~B()
  31 {
  32   #pragma omp atomic
  33     dc++;
  34 }
  35
  36 B::B(const B &)
  37 {
  38   #pragma omp atomic
  39     cc++;
  40 }
  41
  42 B& B::operator=(const B &)
  43 {
  44   #pragma omp atomic
  45     ac++;
  46   return *this;
  47 }
  48
  49 void B::doit()
  50 {
  51   #pragma omp atomic
  52     xc++;
  53 }
  54
  55 void B::clear()
  56 {
  57   ic = 0;
  58   dc = 0;
  59   cc = 0;
  60   ac = 0;
  61   xc = 0;
  62 }
  63
  64 static int n;
  65
  66 void f1(B &a)
  67 {
  68   B b;
  69   B &c = b;
  70   #pragma omp parallel default(none) private(a, c) shared (n)
  71     {
  72       #pragma omp master
  73         n = omp_get_num_threads ();
  74       a.doit();
  75       c.doit();
  76     }
  77 }
  78
  79 void f2(B &a)
  80 {
  81   B b;
  82   B &c = b;
  83   #pragma omp parallel default(none) firstprivate(a, c) shared(n)
  84     {
  85       #pragma omp master
  86         n = omp_get_num_threads ();
  87       a.doit();
  88       c.doit();
  89     }
  90 }
  91
  92 void f3(B &a)
  93 {
  94   B b;
  95   B &c = b;
  96   #pragma omp parallel default(none) shared(n, a, c)
  97     {
  98       #pragma omp master
  99         n = omp_get_num_threads ();
 100       #pragma omp for lastprivate (a, c)
 101       for (int i = 0; i < omp_get_num_threads (); i++)
 102         {
 103           a.doit();
 104           c.doit();
 105         }
 106     }
 107 }
 108
 109 void f4()
 110 {
 111   B b;
 112   B &c = b;
 113   #pragma omp parallel default(none) private (c) shared (n)
 114     {
 115       B d;
 116       B &e = d;
 117       #pragma omp single copyprivate (c, e)
 118       {
 119         c.doit();
 120         e.doit();
 121       }
 122       c.doit();
 123       e.doit();
 124     }
 125 }
 126
 127 void f5(B (&a)[2])
 128 {
 129   B b[2];
 130   B (&c)[2] = b;
 131   #pragma omp parallel default(none) private(a, c) shared (n)
 132     {
 133       #pragma omp master
 134         n = omp_get_num_threads ();
 135       a[0].doit();
 136       a[1].doit();
 137       c[0].doit();
 138       c[1].doit();
 139     }
 140 }
 141
 142 void f6(B (&a)[2])
 143 {
 144   B b[2];
 145   B (&c)[2] = b;
 146   #pragma omp parallel default(none) firstprivate(a, c) shared (n)
 147     {
 148       #pragma omp master
 149         n = omp_get_num_threads ();
 150       a[0].doit();
 151       a[1].doit();
 152       c[0].doit();
 153       c[1].doit();
 154     }
 155 }
 156
 157 void f7(B (&a)[2])
 158 {
 159   B b[2];
 160   B (&c)[2] = b;
 161   #pragma omp parallel default(none) shared(n, a, c)
 162     {
 163       #pragma omp master
 164         n = omp_get_num_threads ();
 165       #pragma omp for lastprivate (a, c)
 166       for (int i = 0; i < omp_get_num_threads (); i++)
 167         {
 168           a[0].doit();
 169           a[1].doit();
 170           c[0].doit();
 171           c[1].doit();
 172         }
 173     }
 174 }
 175
 176 void f8()
 177 {
 178   B b[2];
 179   B (&c)[2] = b;
 180   #pragma omp parallel default(none) private (c) shared (n)
 181     {
 182       B d[2];
 183       B (&e)[2] = d;
 184       #pragma omp single copyprivate (c, e)
 185       {
 186         c[0].doit();
 187         c[1].doit();
 188         e[0].doit();
 189         e[1].doit();
 190       }
 191       c[0].doit();
 192       c[1].doit();
 193       e[0].doit();
 194       e[1].doit();
 195     }
 196 }
 197
 198 int main()
 199 {
 200   {
 201     B a;
 202     f1(a);
 203   }
 204   assert (B::xc == 2*n && B::ic == 2*n+2 && B::dc == 2*n+2 && B::ac == 0 && B::cc == 0);
 205   B::clear();
 206   {
 207     B a;
 208     f2(a);
 209   }
 210   assert (B::xc == 2*n && B::ic == 2 && B::dc == 2*n+2 && B::ac == 0 && B::cc == 2*n);
 211   B::clear();
 212   {
 213     B a;
 214     f3(a);
 215   }
 216   assert (B::xc == 2*n && B::ic == 2*n+2 && B::dc == 2*n+2 && B::ac == 2 && B::cc == 0);
 217   B::clear();
 218   f4();
 219   assert (B::xc == 2*n+2 && B::ic == 2*n+1 && B::dc == 2*n+1 && B::ac == 2*n-2 && B::cc == 0);
 220   B::clear();
 221   {
 222     B a[2];
 223     f5(a);
 224   }
 225   assert (B::xc == 4*n && B::ic == 4*n+4 && B::dc == 4*n+4 && B::ac == 0 && B::cc == 0);
 226   B::clear();
 227   {
 228     B a[2];
 229     f6(a);
 230   }
 231   assert (B::xc == 4*n && B::ic == 4 && B::dc == 4*n+4 && B::ac == 0 && B::cc == 4*n);
 232   B::clear();
 233   {
 234     B a[2];
 235     f7(a);
 236   }
 237   assert (B::xc == 4*n && B::ic == 4*n+4 && B::dc == 4*n+4 && B::ac == 4 && B::cc == 0);
 238   B::clear();
 239   f8();
 240   assert (B::xc == 4*n+4 && B::ic == 4*n+2 && B::dc == 4*n+2 && B::ac == 4*n-4 && B::cc == 0);
 241   return 0;
 242 }