libgomp/testsuite/libgomp.c++/baseptrs-3.C

   1 #include <cstdlib>
   2 #include <cstring>
   3 #include <cassert>
   4
   5 struct sa0
   6 {
   7   int *ptr;
   8 };
   9
  10 struct sb0
  11 {
  12   int arr[10];
  13 };
  14
  15 struct sc0
  16 {
  17   sa0 a;
  18   sb0 b;
  19   sc0 (sa0 &my_a, sb0 &my_b) : a(my_a), b(my_b) {}
  20 };
  21
  22 void
  23 foo0 ()
  24 {
  25   sa0 my_a;
  26   sb0 my_b;
  27
  28   my_a.ptr = (int *) malloc (sizeof (int) * 10);
  29   sc0 my_c(my_a, my_b);
  30
  31   memset (my_c.a.ptr, 0, sizeof (int) * 10);
  32
  33   #pragma omp target map (my_c.a.ptr, my_c.a.ptr[:10])
  34   {
  35     for (int i = 0; i < 10; i++)
  36       my_c.a.ptr[i] = i;
  37   }
  38
  39   for (int i = 0; i < 10; i++)
  40     assert (my_c.a.ptr[i] == i);
  41
  42   memset (my_c.b.arr, 0, sizeof (int) * 10);
  43
  44   #pragma omp target map (my_c.b.arr[:10])
  45   {
  46     for (int i = 0; i < 10; i++)
  47       my_c.b.arr[i] = i;
  48   }
  49
  50   for (int i = 0; i < 10; i++)
  51     assert (my_c.b.arr[i] == i);
  52
  53   free (my_a.ptr);
  54 }
  55
  56 struct sa
  57 {
  58   int *ptr;
  59 };
  60
  61 struct sb
  62 {
  63   int arr[10];
  64 };
  65
  66 struct sc
  67 {
  68   sa &a;
  69   sb &b;
  70   sc (sa &my_a, sb &my_b) : a(my_a), b(my_b) {}
  71 };
  72
  73 void
  74 foo ()
  75 {
  76   sa my_a;
  77   sb my_b;
  78
  79   my_a.ptr = (int *) malloc (sizeof (int) * 10);
  80   sc my_c(my_a, my_b);
  81
  82   memset (my_c.a.ptr, 0, sizeof (int) * 10);
  83
  84   #pragma omp target map (my_c.a.ptr, my_c.a.ptr[:10])
  85   {
  86     for (int i = 0; i < 10; i++)
  87       my_c.a.ptr[i] = i;
  88   }
  89
  90   for (int i = 0; i < 10; i++)
  91     assert (my_c.a.ptr[i] == i);
  92
  93   memset (my_c.b.arr, 0, sizeof (int) * 10);
  94
  95   #pragma omp target map (my_c.b.arr[:10])
  96   {
  97     for (int i = 0; i < 10; i++)
  98       my_c.b.arr[i] = i;
  99   }
 100
 101   for (int i = 0; i < 10; i++)
 102     assert (my_c.b.arr[i] == i);
 103
 104   free (my_a.ptr);
 105 }
 106
 107 void
 108 bar ()
 109 {
 110   sa my_a;
 111   sb my_b;
 112
 113   my_a.ptr = (int *) malloc (sizeof (int) * 10);
 114   sc my_c(my_a, my_b);
 115   sc &my_cref = my_c;
 116
 117   memset (my_cref.a.ptr, 0, sizeof (int) * 10);
 118
 119   #pragma omp target map (my_cref.a.ptr, my_cref.a.ptr[:10])
 120   {
 121     for (int i = 0; i < 10; i++)
 122       my_cref.a.ptr[i] = i;
 123   }
 124
 125   for (int i = 0; i < 10; i++)
 126     assert (my_cref.a.ptr[i] == i);
 127
 128   memset (my_cref.b.arr, 0, sizeof (int) * 10);
 129
 130   #pragma omp target map (my_cref.b.arr[:10])
 131   {
 132     for (int i = 0; i < 10; i++)
 133       my_cref.b.arr[i] = i;
 134   }
 135
 136   for (int i = 0; i < 10; i++)
 137     assert (my_cref.b.arr[i] == i);
 138
 139   free (my_a.ptr);
 140 }
 141
 142 struct scp0
 143 {
 144   sa *a;
 145   sb *b;
 146   scp0 (sa *my_a, sb *my_b) : a(my_a), b(my_b) {}
 147 };
 148
 149 void
 150 foop0 ()
 151 {
 152   sa *my_a = new sa;
 153   sb *my_b = new sb;
 154
 155   my_a->ptr = new int[10];
 156   scp0 *my_c = new scp0(my_a, my_b);
 157
 158   memset (my_c->a->ptr, 0, sizeof (int) * 10);
 159
 160   #pragma omp target map (my_c->a, my_c->a[:1], my_c->a->ptr, my_c->a->ptr[:10])
 161   {
 162     for (int i = 0; i < 10; i++)
 163       my_c->a->ptr[i] = i;
 164   }
 165
 166   for (int i = 0; i < 10; i++)
 167     assert (my_c->a->ptr[i] == i);
 168
 169   memset (my_c->b->arr, 0, sizeof (int) * 10);
 170
 171   #pragma omp target map (my_c->b, my_c->b[:1], my_c->b->arr[:10])
 172   {
 173     for (int i = 0; i < 10; i++)
 174       my_c->b->arr[i] = i;
 175   }
 176
 177   for (int i = 0; i < 10; i++)
 178     assert (my_c->b->arr[i] == i);
 179
 180   delete[] my_a->ptr;
 181   delete my_a;
 182   delete my_b;
 183 }
 184
 185 struct scp
 186 {
 187   sa *&a;
 188   sb *&b;
 189   scp (sa *&my_a, sb *&my_b) : a(my_a), b(my_b) {}
 190 };
 191
 192 void
 193 foop ()
 194 {
 195   sa *my_a = new sa;
 196   sb *my_b = new sb;
 197
 198   my_a->ptr = new int[10];
 199   scp *my_c = new scp(my_a, my_b);
 200
 201   memset (my_c->a->ptr, 0, sizeof (int) * 10);
 202
 203   #pragma omp target map (my_c->a, my_c->a[:1], my_c->a->ptr, my_c->a->ptr[:10])
 204   {
 205     for (int i = 0; i < 10; i++)
 206       my_c->a->ptr[i] = i;
 207   }
 208
 209   for (int i = 0; i < 10; i++)
 210     assert (my_c->a->ptr[i] == i);
 211
 212   memset (my_c->b->arr, 0, sizeof (int) * 10);
 213
 214   #pragma omp target map (my_c->b, my_c->b[:1], my_c->b->arr[:10])
 215   {
 216     for (int i = 0; i < 10; i++)
 217       my_c->b->arr[i] = i;
 218   }
 219
 220   for (int i = 0; i < 10; i++)
 221     assert (my_c->b->arr[i] == i);
 222
 223   delete[] my_a->ptr;
 224   delete my_a;
 225   delete my_b;
 226 }
 227
 228 void
 229 barp ()
 230 {
 231   sa *my_a = new sa;
 232   sb *my_b = new sb;
 233
 234   my_a->ptr = new int[10];
 235   scp *my_c = new scp(my_a, my_b);
 236   scp *&my_cref = my_c;
 237
 238   memset (my_cref->a->ptr, 0, sizeof (int) * 10);
 239
 240   #pragma omp target map (my_cref->a, my_cref->a[:1], my_cref->a->ptr, \
 241                           my_cref->a->ptr[:10])
 242   {
 243     for (int i = 0; i < 10; i++)
 244       my_cref->a->ptr[i] = i;
 245   }
 246
 247   for (int i = 0; i < 10; i++)
 248     assert (my_cref->a->ptr[i] == i);
 249
 250   memset (my_cref->b->arr, 0, sizeof (int) * 10);
 251
 252   #pragma omp target map (my_cref->b, my_cref->b[:1], my_cref->b->arr[:10])
 253   {
 254     for (int i = 0; i < 10; i++)
 255       my_cref->b->arr[i] = i;
 256   }
 257
 258   for (int i = 0; i < 10; i++)
 259     assert (my_cref->b->arr[i] == i);
 260
 261   delete my_a->ptr;
 262   delete my_a;
 263   delete my_b;
 264 }
 265
 266 int main (int argc, char *argv[])
 267 {
 268   foo0 ();
 269   foo ();
 270   bar ();
 271   foop0 ();
 272   foop ();
 273   barp ();
 274   return 0;
 275 }