|
111
|
1 /* Copyright (C) 2013-2017 Free Software Foundation, Inc.
|
|
|
2
|
|
|
3 Contributed by Mentor Embedded.
|
|
|
4
|
|
|
5 This file is part of the GNU Offloading and Multi Processing Library
|
|
|
6 (libgomp).
|
|
|
7
|
|
|
8 Libgomp is free software; you can redistribute it and/or modify it
|
|
|
9 under the terms of the GNU General Public License as published by
|
|
|
10 the Free Software Foundation; either version 3, or (at your option)
|
|
|
11 any later version.
|
|
|
12
|
|
|
13 Libgomp is distributed in the hope that it will be useful, but WITHOUT ANY
|
|
|
14 WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
|
|
|
15 FOR A PARTICULAR PURPOSE. See the GNU General Public License for
|
|
|
16 more details.
|
|
|
17
|
|
|
18 Under Section 7 of GPL version 3, you are granted additional
|
|
|
19 permissions described in the GCC Runtime Library Exception, version
|
|
|
20 3.1, as published by the Free Software Foundation.
|
|
|
21
|
|
|
22 You should have received a copy of the GNU General Public License and
|
|
|
23 a copy of the GCC Runtime Library Exception along with this program;
|
|
|
24 see the files COPYING3 and COPYING.RUNTIME respectively. If not, see
|
|
|
25 <http://www.gnu.org/licenses/>. */
|
|
|
26
|
|
|
27 /* This file handles OpenACC constructs. */
|
|
|
28
|
|
|
29 #include "openacc.h"
|
|
|
30 #include "libgomp.h"
|
|
|
31 #include "libgomp_g.h"
|
|
|
32 #include "gomp-constants.h"
|
|
|
33 #include "oacc-int.h"
|
|
|
34 #ifdef HAVE_INTTYPES_H
|
|
|
35 # include <inttypes.h> /* For PRIu64. */
|
|
|
36 #endif
|
|
|
37 #include <string.h>
|
|
|
38 #include <stdarg.h>
|
|
|
39 #include <assert.h>
|
|
|
40
|
|
|
41 static int
|
|
|
42 find_pset (int pos, size_t mapnum, unsigned short *kinds)
|
|
|
43 {
|
|
|
44 if (pos + 1 >= mapnum)
|
|
|
45 return 0;
|
|
|
46
|
|
|
47 unsigned char kind = kinds[pos+1] & 0xff;
|
|
|
48
|
|
|
49 return kind == GOMP_MAP_TO_PSET;
|
|
|
50 }
|
|
|
51
|
|
|
52 static void goacc_wait (int async, int num_waits, va_list *ap);
|
|
|
53
|
|
|
54
|
|
|
55 /* Launch a possibly offloaded function on DEVICE. FN is the host fn
|
|
|
56 address. MAPNUM, HOSTADDRS, SIZES & KINDS describe the memory
|
|
|
57 blocks to be copied to/from the device. Varadic arguments are
|
|
|
58 keyed optional parameters terminated with a zero. */
|
|
|
59
|
|
|
60 void
|
|
|
61 GOACC_parallel_keyed (int device, void (*fn) (void *),
|
|
|
62 size_t mapnum, void **hostaddrs, size_t *sizes,
|
|
|
63 unsigned short *kinds, ...)
|
|
|
64 {
|
|
|
65 bool host_fallback = device == GOMP_DEVICE_HOST_FALLBACK;
|
|
|
66 va_list ap;
|
|
|
67 struct goacc_thread *thr;
|
|
|
68 struct gomp_device_descr *acc_dev;
|
|
|
69 struct target_mem_desc *tgt;
|
|
|
70 void **devaddrs;
|
|
|
71 unsigned int i;
|
|
|
72 struct splay_tree_key_s k;
|
|
|
73 splay_tree_key tgt_fn_key;
|
|
|
74 void (*tgt_fn);
|
|
|
75 int async = GOMP_ASYNC_SYNC;
|
|
|
76 unsigned dims[GOMP_DIM_MAX];
|
|
|
77 unsigned tag;
|
|
|
78
|
|
|
79 #ifdef HAVE_INTTYPES_H
|
|
|
80 gomp_debug (0, "%s: mapnum=%"PRIu64", hostaddrs=%p, size=%p, kinds=%p\n",
|
|
|
81 __FUNCTION__, (uint64_t) mapnum, hostaddrs, sizes, kinds);
|
|
|
82 #else
|
|
|
83 gomp_debug (0, "%s: mapnum=%lu, hostaddrs=%p, sizes=%p, kinds=%p\n",
|
|
|
84 __FUNCTION__, (unsigned long) mapnum, hostaddrs, sizes, kinds);
|
|
|
85 #endif
|
|
|
86 goacc_lazy_initialize ();
|
|
|
87
|
|
|
88 thr = goacc_thread ();
|
|
|
89 acc_dev = thr->dev;
|
|
|
90
|
|
|
91 /* Host fallback if "if" clause is false or if the current device is set to
|
|
|
92 the host. */
|
|
|
93 if (host_fallback)
|
|
|
94 {
|
|
|
95 goacc_save_and_set_bind (acc_device_host);
|
|
|
96 fn (hostaddrs);
|
|
|
97 goacc_restore_bind ();
|
|
|
98 return;
|
|
|
99 }
|
|
|
100 else if (acc_device_type (acc_dev->type) == acc_device_host)
|
|
|
101 {
|
|
|
102 fn (hostaddrs);
|
|
|
103 return;
|
|
|
104 }
|
|
|
105
|
|
|
106 /* Default: let the runtime choose. */
|
|
|
107 for (i = 0; i != GOMP_DIM_MAX; i++)
|
|
|
108 dims[i] = 0;
|
|
|
109
|
|
|
110 va_start (ap, kinds);
|
|
|
111 /* TODO: This will need amending when device_type is implemented. */
|
|
|
112 while ((tag = va_arg (ap, unsigned)) != 0)
|
|
|
113 {
|
|
|
114 if (GOMP_LAUNCH_DEVICE (tag))
|
|
|
115 gomp_fatal ("device_type '%d' offload parameters, libgomp is too old",
|
|
|
116 GOMP_LAUNCH_DEVICE (tag));
|
|
|
117
|
|
|
118 switch (GOMP_LAUNCH_CODE (tag))
|
|
|
119 {
|
|
|
120 case GOMP_LAUNCH_DIM:
|
|
|
121 {
|
|
|
122 unsigned mask = GOMP_LAUNCH_OP (tag);
|
|
|
123
|
|
|
124 for (i = 0; i != GOMP_DIM_MAX; i++)
|
|
|
125 if (mask & GOMP_DIM_MASK (i))
|
|
|
126 dims[i] = va_arg (ap, unsigned);
|
|
|
127 }
|
|
|
128 break;
|
|
|
129
|
|
|
130 case GOMP_LAUNCH_ASYNC:
|
|
|
131 {
|
|
|
132 /* Small constant values are encoded in the operand. */
|
|
|
133 async = GOMP_LAUNCH_OP (tag);
|
|
|
134
|
|
|
135 if (async == GOMP_LAUNCH_OP_MAX)
|
|
|
136 async = va_arg (ap, unsigned);
|
|
|
137 break;
|
|
|
138 }
|
|
|
139
|
|
|
140 case GOMP_LAUNCH_WAIT:
|
|
|
141 {
|
|
|
142 unsigned num_waits = GOMP_LAUNCH_OP (tag);
|
|
|
143
|
|
|
144 if (num_waits)
|
|
|
145 goacc_wait (async, num_waits, &ap);
|
|
|
146 break;
|
|
|
147 }
|
|
|
148
|
|
|
149 default:
|
|
|
150 gomp_fatal ("unrecognized offload code '%d',"
|
|
|
151 " libgomp is too old", GOMP_LAUNCH_CODE (tag));
|
|
|
152 }
|
|
|
153 }
|
|
|
154 va_end (ap);
|
|
|
155
|
|
|
156 acc_dev->openacc.async_set_async_func (async);
|
|
|
157
|
|
|
158 if (!(acc_dev->capabilities & GOMP_OFFLOAD_CAP_NATIVE_EXEC))
|
|
|
159 {
|
|
|
160 k.host_start = (uintptr_t) fn;
|
|
|
161 k.host_end = k.host_start + 1;
|
|
|
162 gomp_mutex_lock (&acc_dev->lock);
|
|
|
163 tgt_fn_key = splay_tree_lookup (&acc_dev->mem_map, &k);
|
|
|
164 gomp_mutex_unlock (&acc_dev->lock);
|
|
|
165
|
|
|
166 if (tgt_fn_key == NULL)
|
|
|
167 gomp_fatal ("target function wasn't mapped");
|
|
|
168
|
|
|
169 tgt_fn = (void (*)) tgt_fn_key->tgt_offset;
|
|
|
170 }
|
|
|
171 else
|
|
|
172 tgt_fn = (void (*)) fn;
|
|
|
173
|
|
|
174 tgt = gomp_map_vars (acc_dev, mapnum, hostaddrs, NULL, sizes, kinds, true,
|
|
|
175 GOMP_MAP_VARS_OPENACC);
|
|
|
176
|
|
|
177 devaddrs = gomp_alloca (sizeof (void *) * mapnum);
|
|
|
178 for (i = 0; i < mapnum; i++)
|
|
|
179 devaddrs[i] = (void *) (tgt->list[i].key->tgt->tgt_start
|
|
|
180 + tgt->list[i].key->tgt_offset);
|
|
|
181
|
|
|
182 acc_dev->openacc.exec_func (tgt_fn, mapnum, hostaddrs, devaddrs,
|
|
|
183 async, dims, tgt);
|
|
|
184
|
|
|
185 /* If running synchronously, unmap immediately. */
|
|
|
186 if (async < acc_async_noval)
|
|
|
187 gomp_unmap_vars (tgt, true);
|
|
|
188 else
|
|
|
189 tgt->device_descr->openacc.register_async_cleanup_func (tgt, async);
|
|
|
190
|
|
|
191 acc_dev->openacc.async_set_async_func (acc_async_sync);
|
|
|
192 }
|
|
|
193
|
|
|
194 /* Legacy entry point, only provide host execution. */
|
|
|
195
|
|
|
196 void
|
|
|
197 GOACC_parallel (int device, void (*fn) (void *),
|
|
|
198 size_t mapnum, void **hostaddrs, size_t *sizes,
|
|
|
199 unsigned short *kinds,
|
|
|
200 int num_gangs, int num_workers, int vector_length,
|
|
|
201 int async, int num_waits, ...)
|
|
|
202 {
|
|
|
203 goacc_save_and_set_bind (acc_device_host);
|
|
|
204 fn (hostaddrs);
|
|
|
205 goacc_restore_bind ();
|
|
|
206 }
|
|
|
207
|
|
|
208 void
|
|
|
209 GOACC_data_start (int device, size_t mapnum,
|
|
|
210 void **hostaddrs, size_t *sizes, unsigned short *kinds)
|
|
|
211 {
|
|
|
212 bool host_fallback = device == GOMP_DEVICE_HOST_FALLBACK;
|
|
|
213 struct target_mem_desc *tgt;
|
|
|
214
|
|
|
215 #ifdef HAVE_INTTYPES_H
|
|
|
216 gomp_debug (0, "%s: mapnum=%"PRIu64", hostaddrs=%p, size=%p, kinds=%p\n",
|
|
|
217 __FUNCTION__, (uint64_t) mapnum, hostaddrs, sizes, kinds);
|
|
|
218 #else
|
|
|
219 gomp_debug (0, "%s: mapnum=%lu, hostaddrs=%p, sizes=%p, kinds=%p\n",
|
|
|
220 __FUNCTION__, (unsigned long) mapnum, hostaddrs, sizes, kinds);
|
|
|
221 #endif
|
|
|
222
|
|
|
223 goacc_lazy_initialize ();
|
|
|
224
|
|
|
225 struct goacc_thread *thr = goacc_thread ();
|
|
|
226 struct gomp_device_descr *acc_dev = thr->dev;
|
|
|
227
|
|
|
228 /* Host fallback or 'do nothing'. */
|
|
|
229 if ((acc_dev->capabilities & GOMP_OFFLOAD_CAP_SHARED_MEM)
|
|
|
230 || host_fallback)
|
|
|
231 {
|
|
|
232 tgt = gomp_map_vars (NULL, 0, NULL, NULL, NULL, NULL, true,
|
|
|
233 GOMP_MAP_VARS_OPENACC);
|
|
|
234 tgt->prev = thr->mapped_data;
|
|
|
235 thr->mapped_data = tgt;
|
|
|
236
|
|
|
237 return;
|
|
|
238 }
|
|
|
239
|
|
|
240 gomp_debug (0, " %s: prepare mappings\n", __FUNCTION__);
|
|
|
241 tgt = gomp_map_vars (acc_dev, mapnum, hostaddrs, NULL, sizes, kinds, true,
|
|
|
242 GOMP_MAP_VARS_OPENACC);
|
|
|
243 gomp_debug (0, " %s: mappings prepared\n", __FUNCTION__);
|
|
|
244 tgt->prev = thr->mapped_data;
|
|
|
245 thr->mapped_data = tgt;
|
|
|
246 }
|
|
|
247
|
|
|
248 void
|
|
|
249 GOACC_data_end (void)
|
|
|
250 {
|
|
|
251 struct goacc_thread *thr = goacc_thread ();
|
|
|
252 struct target_mem_desc *tgt = thr->mapped_data;
|
|
|
253
|
|
|
254 gomp_debug (0, " %s: restore mappings\n", __FUNCTION__);
|
|
|
255 thr->mapped_data = tgt->prev;
|
|
|
256 gomp_unmap_vars (tgt, true);
|
|
|
257 gomp_debug (0, " %s: mappings restored\n", __FUNCTION__);
|
|
|
258 }
|
|
|
259
|
|
|
260 void
|
|
|
261 GOACC_enter_exit_data (int device, size_t mapnum,
|
|
|
262 void **hostaddrs, size_t *sizes, unsigned short *kinds,
|
|
|
263 int async, int num_waits, ...)
|
|
|
264 {
|
|
|
265 struct goacc_thread *thr;
|
|
|
266 struct gomp_device_descr *acc_dev;
|
|
|
267 bool host_fallback = device == GOMP_DEVICE_HOST_FALLBACK;
|
|
|
268 bool data_enter = false;
|
|
|
269 size_t i;
|
|
|
270
|
|
|
271 goacc_lazy_initialize ();
|
|
|
272
|
|
|
273 thr = goacc_thread ();
|
|
|
274 acc_dev = thr->dev;
|
|
|
275
|
|
|
276 if ((acc_dev->capabilities & GOMP_OFFLOAD_CAP_SHARED_MEM)
|
|
|
277 || host_fallback)
|
|
|
278 return;
|
|
|
279
|
|
|
280 if (num_waits)
|
|
|
281 {
|
|
|
282 va_list ap;
|
|
|
283
|
|
|
284 va_start (ap, num_waits);
|
|
|
285 goacc_wait (async, num_waits, &ap);
|
|
|
286 va_end (ap);
|
|
|
287 }
|
|
|
288
|
|
|
289 acc_dev->openacc.async_set_async_func (async);
|
|
|
290
|
|
|
291 /* Determine if this is an "acc enter data". */
|
|
|
292 for (i = 0; i < mapnum; ++i)
|
|
|
293 {
|
|
|
294 unsigned char kind = kinds[i] & 0xff;
|
|
|
295
|
|
|
296 if (kind == GOMP_MAP_POINTER || kind == GOMP_MAP_TO_PSET)
|
|
|
297 continue;
|
|
|
298
|
|
|
299 if (kind == GOMP_MAP_FORCE_ALLOC
|
|
|
300 || kind == GOMP_MAP_FORCE_PRESENT
|
|
|
301 || kind == GOMP_MAP_FORCE_TO)
|
|
|
302 {
|
|
|
303 data_enter = true;
|
|
|
304 break;
|
|
|
305 }
|
|
|
306
|
|
|
307 if (kind == GOMP_MAP_DELETE
|
|
|
308 || kind == GOMP_MAP_FORCE_FROM)
|
|
|
309 break;
|
|
|
310
|
|
|
311 gomp_fatal (">>>> GOACC_enter_exit_data UNHANDLED kind 0x%.2x",
|
|
|
312 kind);
|
|
|
313 }
|
|
|
314
|
|
|
315 if (data_enter)
|
|
|
316 {
|
|
|
317 for (i = 0; i < mapnum; i++)
|
|
|
318 {
|
|
|
319 unsigned char kind = kinds[i] & 0xff;
|
|
|
320
|
|
|
321 /* Scan for PSETs. */
|
|
|
322 int psets = find_pset (i, mapnum, kinds);
|
|
|
323
|
|
|
324 if (!psets)
|
|
|
325 {
|
|
|
326 switch (kind)
|
|
|
327 {
|
|
|
328 case GOMP_MAP_POINTER:
|
|
|
329 gomp_acc_insert_pointer (1, &hostaddrs[i], &sizes[i],
|
|
|
330 &kinds[i]);
|
|
|
331 break;
|
|
|
332 case GOMP_MAP_FORCE_ALLOC:
|
|
|
333 acc_create (hostaddrs[i], sizes[i]);
|
|
|
334 break;
|
|
|
335 case GOMP_MAP_FORCE_PRESENT:
|
|
|
336 acc_present_or_copyin (hostaddrs[i], sizes[i]);
|
|
|
337 break;
|
|
|
338 case GOMP_MAP_FORCE_TO:
|
|
|
339 acc_present_or_copyin (hostaddrs[i], sizes[i]);
|
|
|
340 break;
|
|
|
341 default:
|
|
|
342 gomp_fatal (">>>> GOACC_enter_exit_data UNHANDLED kind 0x%.2x",
|
|
|
343 kind);
|
|
|
344 break;
|
|
|
345 }
|
|
|
346 }
|
|
|
347 else
|
|
|
348 {
|
|
|
349 gomp_acc_insert_pointer (3, &hostaddrs[i], &sizes[i], &kinds[i]);
|
|
|
350 /* Increment 'i' by two because OpenACC requires fortran
|
|
|
351 arrays to be contiguous, so each PSET is associated with
|
|
|
352 one of MAP_FORCE_ALLOC/MAP_FORCE_PRESET/MAP_FORCE_TO, and
|
|
|
353 one MAP_POINTER. */
|
|
|
354 i += 2;
|
|
|
355 }
|
|
|
356 }
|
|
|
357 }
|
|
|
358 else
|
|
|
359 for (i = 0; i < mapnum; ++i)
|
|
|
360 {
|
|
|
361 unsigned char kind = kinds[i] & 0xff;
|
|
|
362
|
|
|
363 int psets = find_pset (i, mapnum, kinds);
|
|
|
364
|
|
|
365 if (!psets)
|
|
|
366 {
|
|
|
367 switch (kind)
|
|
|
368 {
|
|
|
369 case GOMP_MAP_POINTER:
|
|
|
370 gomp_acc_remove_pointer (hostaddrs[i], (kinds[i] & 0xff)
|
|
|
371 == GOMP_MAP_FORCE_FROM,
|
|
|
372 async, 1);
|
|
|
373 break;
|
|
|
374 case GOMP_MAP_DELETE:
|
|
|
375 acc_delete (hostaddrs[i], sizes[i]);
|
|
|
376 break;
|
|
|
377 case GOMP_MAP_FORCE_FROM:
|
|
|
378 acc_copyout (hostaddrs[i], sizes[i]);
|
|
|
379 break;
|
|
|
380 default:
|
|
|
381 gomp_fatal (">>>> GOACC_enter_exit_data UNHANDLED kind 0x%.2x",
|
|
|
382 kind);
|
|
|
383 break;
|
|
|
384 }
|
|
|
385 }
|
|
|
386 else
|
|
|
387 {
|
|
|
388 gomp_acc_remove_pointer (hostaddrs[i], (kinds[i] & 0xff)
|
|
|
389 == GOMP_MAP_FORCE_FROM, async, 3);
|
|
|
390 /* See the above comment. */
|
|
|
391 i += 2;
|
|
|
392 }
|
|
|
393 }
|
|
|
394
|
|
|
395 acc_dev->openacc.async_set_async_func (acc_async_sync);
|
|
|
396 }
|
|
|
397
|
|
|
398 static void
|
|
|
399 goacc_wait (int async, int num_waits, va_list *ap)
|
|
|
400 {
|
|
|
401 struct goacc_thread *thr = goacc_thread ();
|
|
|
402 struct gomp_device_descr *acc_dev = thr->dev;
|
|
|
403
|
|
|
404 while (num_waits--)
|
|
|
405 {
|
|
|
406 int qid = va_arg (*ap, int);
|
|
|
407
|
|
|
408 if (acc_async_test (qid))
|
|
|
409 continue;
|
|
|
410
|
|
|
411 if (async == acc_async_sync)
|
|
|
412 acc_wait (qid);
|
|
|
413 else if (qid == async)
|
|
|
414 ;/* If we're waiting on the same asynchronous queue as we're
|
|
|
415 launching on, the queue itself will order work as
|
|
|
416 required, so there's no need to wait explicitly. */
|
|
|
417 else
|
|
|
418 acc_dev->openacc.async_wait_async_func (qid, async);
|
|
|
419 }
|
|
|
420 }
|
|
|
421
|
|
|
422 void
|
|
|
423 GOACC_update (int device, size_t mapnum,
|
|
|
424 void **hostaddrs, size_t *sizes, unsigned short *kinds,
|
|
|
425 int async, int num_waits, ...)
|
|
|
426 {
|
|
|
427 bool host_fallback = device == GOMP_DEVICE_HOST_FALLBACK;
|
|
|
428 size_t i;
|
|
|
429
|
|
|
430 goacc_lazy_initialize ();
|
|
|
431
|
|
|
432 struct goacc_thread *thr = goacc_thread ();
|
|
|
433 struct gomp_device_descr *acc_dev = thr->dev;
|
|
|
434
|
|
|
435 if ((acc_dev->capabilities & GOMP_OFFLOAD_CAP_SHARED_MEM)
|
|
|
436 || host_fallback)
|
|
|
437 return;
|
|
|
438
|
|
|
439 if (num_waits)
|
|
|
440 {
|
|
|
441 va_list ap;
|
|
|
442
|
|
|
443 va_start (ap, num_waits);
|
|
|
444 goacc_wait (async, num_waits, &ap);
|
|
|
445 va_end (ap);
|
|
|
446 }
|
|
|
447
|
|
|
448 acc_dev->openacc.async_set_async_func (async);
|
|
|
449
|
|
|
450 for (i = 0; i < mapnum; ++i)
|
|
|
451 {
|
|
|
452 unsigned char kind = kinds[i] & 0xff;
|
|
|
453
|
|
|
454 switch (kind)
|
|
|
455 {
|
|
|
456 case GOMP_MAP_POINTER:
|
|
|
457 case GOMP_MAP_TO_PSET:
|
|
|
458 break;
|
|
|
459
|
|
|
460 case GOMP_MAP_FORCE_TO:
|
|
|
461 acc_update_device (hostaddrs[i], sizes[i]);
|
|
|
462 break;
|
|
|
463
|
|
|
464 case GOMP_MAP_FORCE_FROM:
|
|
|
465 acc_update_self (hostaddrs[i], sizes[i]);
|
|
|
466 break;
|
|
|
467
|
|
|
468 default:
|
|
|
469 gomp_fatal (">>>> GOACC_update UNHANDLED kind 0x%.2x", kind);
|
|
|
470 break;
|
|
|
471 }
|
|
|
472 }
|
|
|
473
|
|
|
474 acc_dev->openacc.async_set_async_func (acc_async_sync);
|
|
|
475 }
|
|
|
476
|
|
|
477 void
|
|
|
478 GOACC_wait (int async, int num_waits, ...)
|
|
|
479 {
|
|
|
480 if (num_waits)
|
|
|
481 {
|
|
|
482 va_list ap;
|
|
|
483
|
|
|
484 va_start (ap, num_waits);
|
|
|
485 goacc_wait (async, num_waits, &ap);
|
|
|
486 va_end (ap);
|
|
|
487 }
|
|
|
488 else if (async == acc_async_sync)
|
|
|
489 acc_wait_all ();
|
|
|
490 else if (async == acc_async_noval)
|
|
|
491 goacc_thread ()->dev->openacc.async_wait_all_async_func (acc_async_noval);
|
|
|
492 }
|
|
|
493
|
|
|
494 int
|
|
|
495 GOACC_get_num_threads (void)
|
|
|
496 {
|
|
|
497 return 1;
|
|
|
498 }
|
|
|
499
|
|
|
500 int
|
|
|
501 GOACC_get_thread_num (void)
|
|
|
502 {
|
|
|
503 return 0;
|
|
|
504 }
|
|
|
505
|
|
|
506 void
|
|
|
507 GOACC_declare (int device, size_t mapnum,
|
|
|
508 void **hostaddrs, size_t *sizes, unsigned short *kinds)
|
|
|
509 {
|
|
|
510 int i;
|
|
|
511
|
|
|
512 for (i = 0; i < mapnum; i++)
|
|
|
513 {
|
|
|
514 unsigned char kind = kinds[i] & 0xff;
|
|
|
515
|
|
|
516 if (kind == GOMP_MAP_POINTER || kind == GOMP_MAP_TO_PSET)
|
|
|
517 continue;
|
|
|
518
|
|
|
519 switch (kind)
|
|
|
520 {
|
|
|
521 case GOMP_MAP_FORCE_ALLOC:
|
|
|
522 case GOMP_MAP_FORCE_FROM:
|
|
|
523 case GOMP_MAP_FORCE_TO:
|
|
|
524 case GOMP_MAP_POINTER:
|
|
|
525 case GOMP_MAP_DELETE:
|
|
|
526 GOACC_enter_exit_data (device, 1, &hostaddrs[i], &sizes[i],
|
|
|
527 &kinds[i], 0, 0);
|
|
|
528 break;
|
|
|
529
|
|
|
530 case GOMP_MAP_FORCE_DEVICEPTR:
|
|
|
531 break;
|
|
|
532
|
|
|
533 case GOMP_MAP_ALLOC:
|
|
|
534 if (!acc_is_present (hostaddrs[i], sizes[i]))
|
|
|
535 GOACC_enter_exit_data (device, 1, &hostaddrs[i], &sizes[i],
|
|
|
536 &kinds[i], 0, 0);
|
|
|
537 break;
|
|
|
538
|
|
|
539 case GOMP_MAP_TO:
|
|
|
540 GOACC_enter_exit_data (device, 1, &hostaddrs[i], &sizes[i],
|
|
|
541 &kinds[i], 0, 0);
|
|
|
542
|
|
|
543 break;
|
|
|
544
|
|
|
545 case GOMP_MAP_FROM:
|
|
|
546 kinds[i] = GOMP_MAP_FORCE_FROM;
|
|
|
547 GOACC_enter_exit_data (device, 1, &hostaddrs[i], &sizes[i],
|
|
|
548 &kinds[i], 0, 0);
|
|
|
549 break;
|
|
|
550
|
|
|
551 case GOMP_MAP_FORCE_PRESENT:
|
|
|
552 if (!acc_is_present (hostaddrs[i], sizes[i]))
|
|
|
553 gomp_fatal ("[%p,%ld] is not mapped", hostaddrs[i],
|
|
|
554 (unsigned long) sizes[i]);
|
|
|
555 break;
|
|
|
556
|
|
|
557 default:
|
|
|
558 assert (0);
|
|
|
559 break;
|
|
|
560 }
|
|
|
561 }
|
|
|
562 }
|
