oacc-parallel.c revision 1.1.1.9
1 /* Copyright (C) 2013-2022 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 "gomp-constants.h" 32 #include "oacc-int.h" 33 #ifdef HAVE_INTTYPES_H 34 # include <inttypes.h> /* For PRIu64. */ 35 #endif 36 #include <string.h> 37 #include <stdarg.h> 38 #include <assert.h> 39 40 41 /* In the ABI, the GOACC_FLAGs are encoded as an inverted bitmask, so that we 42 continue to support the following two legacy values. */ 43 _Static_assert (GOACC_FLAGS_UNMARSHAL (GOMP_DEVICE_ICV) == 0, 44 "legacy GOMP_DEVICE_ICV broken"); 45 _Static_assert (GOACC_FLAGS_UNMARSHAL (GOMP_DEVICE_HOST_FALLBACK) 46 == GOACC_FLAG_HOST_FALLBACK, 47 "legacy GOMP_DEVICE_HOST_FALLBACK broken"); 48 49 50 /* Handle the mapping pair that are presented when a 51 deviceptr clause is used with Fortran. */ 52 53 static void 54 handle_ftn_pointers (size_t mapnum, void **hostaddrs, size_t *sizes, 55 unsigned short *kinds) 56 { 57 int i; 58 59 for (i = 0; i < mapnum; i++) 60 { 61 unsigned short kind1 = kinds[i] & 0xff; 62 63 /* Handle Fortran deviceptr clause. */ 64 if (kind1 == GOMP_MAP_FORCE_DEVICEPTR) 65 { 66 unsigned short kind2; 67 68 if (i < (signed)mapnum - 1) 69 kind2 = kinds[i + 1] & 0xff; 70 else 71 kind2 = 0xffff; 72 73 if (sizes[i] == sizeof (void *)) 74 continue; 75 76 /* At this point, we're dealing with a Fortran deviceptr. 77 If the next element is not what we're expecting, then 78 this is an instance of where the deviceptr variable was 79 not used within the region and the pointer was removed 80 by the gimplifier. */ 81 if (kind2 == GOMP_MAP_POINTER 82 && sizes[i + 1] == 0 83 && hostaddrs[i] == *(void **)hostaddrs[i + 1]) 84 { 85 kinds[i+1] = kinds[i]; 86 sizes[i+1] = sizeof (void *); 87 } 88 89 /* Invalidate the entry. */ 90 hostaddrs[i] = NULL; 91 } 92 } 93 } 94 95 96 /* Launch a possibly offloaded function with FLAGS. FN is the host fn 97 address. MAPNUM, HOSTADDRS, SIZES & KINDS describe the memory 98 blocks to be copied to/from the device. Varadic arguments are 99 keyed optional parameters terminated with a zero. */ 100 101 void 102 GOACC_parallel_keyed (int flags_m, void (*fn) (void *), 103 size_t mapnum, void **hostaddrs, size_t *sizes, 104 unsigned short *kinds, ...) 105 { 106 int flags = GOACC_FLAGS_UNMARSHAL (flags_m); 107 108 va_list ap; 109 struct goacc_thread *thr; 110 struct gomp_device_descr *acc_dev; 111 struct target_mem_desc *tgt; 112 void **devaddrs; 113 unsigned int i; 114 struct splay_tree_key_s k; 115 splay_tree_key tgt_fn_key; 116 void (*tgt_fn); 117 int async = GOMP_ASYNC_SYNC; 118 unsigned dims[GOMP_DIM_MAX]; 119 unsigned tag; 120 121 #ifdef HAVE_INTTYPES_H 122 gomp_debug (0, "%s: mapnum=%"PRIu64", hostaddrs=%p, size=%p, kinds=%p\n", 123 __FUNCTION__, (uint64_t) mapnum, hostaddrs, sizes, kinds); 124 #else 125 gomp_debug (0, "%s: mapnum=%lu, hostaddrs=%p, sizes=%p, kinds=%p\n", 126 __FUNCTION__, (unsigned long) mapnum, hostaddrs, sizes, kinds); 127 #endif 128 goacc_lazy_initialize (); 129 130 thr = goacc_thread (); 131 acc_dev = thr->dev; 132 133 bool profiling_p = GOACC_PROFILING_DISPATCH_P (true); 134 135 acc_prof_info prof_info; 136 if (profiling_p) 137 { 138 thr->prof_info = &prof_info; 139 140 prof_info.event_type = acc_ev_compute_construct_start; 141 prof_info.valid_bytes = _ACC_PROF_INFO_VALID_BYTES; 142 prof_info.version = _ACC_PROF_INFO_VERSION; 143 prof_info.device_type = acc_device_type (acc_dev->type); 144 prof_info.device_number = acc_dev->target_id; 145 prof_info.thread_id = -1; 146 prof_info.async = async; 147 prof_info.async_queue = prof_info.async; 148 prof_info.src_file = NULL; 149 prof_info.func_name = NULL; 150 prof_info.line_no = -1; 151 prof_info.end_line_no = -1; 152 prof_info.func_line_no = -1; 153 prof_info.func_end_line_no = -1; 154 } 155 acc_event_info compute_construct_event_info; 156 if (profiling_p) 157 { 158 compute_construct_event_info.other_event.event_type 159 = prof_info.event_type; 160 compute_construct_event_info.other_event.valid_bytes 161 = _ACC_OTHER_EVENT_INFO_VALID_BYTES; 162 compute_construct_event_info.other_event.parent_construct 163 = acc_construct_parallel; 164 compute_construct_event_info.other_event.implicit = 0; 165 compute_construct_event_info.other_event.tool_info = NULL; 166 } 167 acc_api_info api_info; 168 if (profiling_p) 169 { 170 thr->api_info = &api_info; 171 172 api_info.device_api = acc_device_api_none; 173 api_info.valid_bytes = _ACC_API_INFO_VALID_BYTES; 174 api_info.device_type = prof_info.device_type; 175 api_info.vendor = -1; 176 api_info.device_handle = NULL; 177 api_info.context_handle = NULL; 178 api_info.async_handle = NULL; 179 } 180 181 if (profiling_p) 182 goacc_profiling_dispatch (&prof_info, &compute_construct_event_info, 183 &api_info); 184 185 handle_ftn_pointers (mapnum, hostaddrs, sizes, kinds); 186 187 /* Host fallback if "if" clause is false or if the current device is set to 188 the host. */ 189 if (flags & GOACC_FLAG_HOST_FALLBACK) 190 { 191 prof_info.device_type = acc_device_host; 192 api_info.device_type = prof_info.device_type; 193 goacc_save_and_set_bind (acc_device_host); 194 fn (hostaddrs); 195 goacc_restore_bind (); 196 goto out_prof; 197 } 198 else if (acc_device_type (acc_dev->type) == acc_device_host) 199 { 200 fn (hostaddrs); 201 goto out_prof; 202 } 203 204 /* Default: let the runtime choose. */ 205 for (i = 0; i != GOMP_DIM_MAX; i++) 206 dims[i] = 0; 207 208 va_start (ap, kinds); 209 /* TODO: This will need amending when device_type is implemented. */ 210 while ((tag = va_arg (ap, unsigned)) != 0) 211 { 212 if (GOMP_LAUNCH_DEVICE (tag)) 213 gomp_fatal ("device_type '%d' offload parameters, libgomp is too old", 214 GOMP_LAUNCH_DEVICE (tag)); 215 216 switch (GOMP_LAUNCH_CODE (tag)) 217 { 218 case GOMP_LAUNCH_DIM: 219 { 220 unsigned mask = GOMP_LAUNCH_OP (tag); 221 222 for (i = 0; i != GOMP_DIM_MAX; i++) 223 if (mask & GOMP_DIM_MASK (i)) 224 dims[i] = va_arg (ap, unsigned); 225 } 226 break; 227 228 case GOMP_LAUNCH_ASYNC: 229 { 230 /* Small constant values are encoded in the operand. */ 231 async = GOMP_LAUNCH_OP (tag); 232 233 if (async == GOMP_LAUNCH_OP_MAX) 234 async = va_arg (ap, unsigned); 235 236 if (profiling_p) 237 { 238 prof_info.async = async; 239 prof_info.async_queue = prof_info.async; 240 } 241 242 break; 243 } 244 245 case GOMP_LAUNCH_WAIT: 246 { 247 unsigned num_waits = GOMP_LAUNCH_OP (tag); 248 goacc_wait (async, num_waits, &ap); 249 break; 250 } 251 252 default: 253 gomp_fatal ("unrecognized offload code '%d'," 254 " libgomp is too old", GOMP_LAUNCH_CODE (tag)); 255 } 256 } 257 va_end (ap); 258 259 if (!(acc_dev->capabilities & GOMP_OFFLOAD_CAP_NATIVE_EXEC)) 260 { 261 k.host_start = (uintptr_t) fn; 262 k.host_end = k.host_start + 1; 263 gomp_mutex_lock (&acc_dev->lock); 264 tgt_fn_key = splay_tree_lookup (&acc_dev->mem_map, &k); 265 gomp_mutex_unlock (&acc_dev->lock); 266 267 if (tgt_fn_key == NULL) 268 gomp_fatal ("target function wasn't mapped"); 269 270 tgt_fn = (void (*)) tgt_fn_key->tgt_offset; 271 } 272 else 273 tgt_fn = (void (*)) fn; 274 275 acc_event_info enter_exit_data_event_info; 276 if (profiling_p) 277 { 278 prof_info.event_type = acc_ev_enter_data_start; 279 enter_exit_data_event_info.other_event.event_type 280 = prof_info.event_type; 281 enter_exit_data_event_info.other_event.valid_bytes 282 = _ACC_OTHER_EVENT_INFO_VALID_BYTES; 283 enter_exit_data_event_info.other_event.parent_construct 284 = compute_construct_event_info.other_event.parent_construct; 285 enter_exit_data_event_info.other_event.implicit = 1; 286 enter_exit_data_event_info.other_event.tool_info = NULL; 287 goacc_profiling_dispatch (&prof_info, &enter_exit_data_event_info, 288 &api_info); 289 } 290 291 goacc_aq aq = get_goacc_asyncqueue (async); 292 293 tgt = goacc_map_vars (acc_dev, aq, mapnum, hostaddrs, NULL, sizes, kinds, 294 true, 0); 295 if (profiling_p) 296 { 297 prof_info.event_type = acc_ev_enter_data_end; 298 enter_exit_data_event_info.other_event.event_type 299 = prof_info.event_type; 300 goacc_profiling_dispatch (&prof_info, &enter_exit_data_event_info, 301 &api_info); 302 } 303 304 devaddrs = gomp_alloca (sizeof (void *) * mapnum); 305 for (i = 0; i < mapnum; i++) 306 devaddrs[i] = (void *) gomp_map_val (tgt, hostaddrs, i); 307 308 if (aq == NULL) 309 acc_dev->openacc.exec_func (tgt_fn, mapnum, hostaddrs, devaddrs, dims, 310 tgt); 311 else 312 acc_dev->openacc.async.exec_func (tgt_fn, mapnum, hostaddrs, devaddrs, 313 dims, tgt, aq); 314 315 if (profiling_p) 316 { 317 prof_info.event_type = acc_ev_exit_data_start; 318 enter_exit_data_event_info.other_event.event_type = prof_info.event_type; 319 enter_exit_data_event_info.other_event.tool_info = NULL; 320 goacc_profiling_dispatch (&prof_info, &enter_exit_data_event_info, 321 &api_info); 322 } 323 324 /* If running synchronously (aq == NULL), this will unmap immediately. */ 325 goacc_unmap_vars (tgt, true, aq); 326 327 if (profiling_p) 328 { 329 prof_info.event_type = acc_ev_exit_data_end; 330 enter_exit_data_event_info.other_event.event_type = prof_info.event_type; 331 goacc_profiling_dispatch (&prof_info, &enter_exit_data_event_info, 332 &api_info); 333 } 334 335 out_prof: 336 if (profiling_p) 337 { 338 prof_info.event_type = acc_ev_compute_construct_end; 339 compute_construct_event_info.other_event.event_type 340 = prof_info.event_type; 341 goacc_profiling_dispatch (&prof_info, &compute_construct_event_info, 342 &api_info); 343 344 thr->prof_info = NULL; 345 thr->api_info = NULL; 346 } 347 } 348 349 /* Legacy entry point (GCC 5). Only provide host fallback execution. */ 350 351 void 352 GOACC_parallel (int flags_m, void (*fn) (void *), 353 size_t mapnum, void **hostaddrs, size_t *sizes, 354 unsigned short *kinds, 355 int num_gangs, int num_workers, int vector_length, 356 int async, int num_waits, ...) 357 { 358 goacc_save_and_set_bind (acc_device_host); 359 fn (hostaddrs); 360 goacc_restore_bind (); 361 } 362 363 void 364 GOACC_data_start (int flags_m, size_t mapnum, 365 void **hostaddrs, size_t *sizes, unsigned short *kinds) 366 { 367 int flags = GOACC_FLAGS_UNMARSHAL (flags_m); 368 369 struct target_mem_desc *tgt; 370 371 #ifdef HAVE_INTTYPES_H 372 gomp_debug (0, "%s: mapnum=%"PRIu64", hostaddrs=%p, size=%p, kinds=%p\n", 373 __FUNCTION__, (uint64_t) mapnum, hostaddrs, sizes, kinds); 374 #else 375 gomp_debug (0, "%s: mapnum=%lu, hostaddrs=%p, sizes=%p, kinds=%p\n", 376 __FUNCTION__, (unsigned long) mapnum, hostaddrs, sizes, kinds); 377 #endif 378 379 goacc_lazy_initialize (); 380 381 struct goacc_thread *thr = goacc_thread (); 382 struct gomp_device_descr *acc_dev = thr->dev; 383 384 bool profiling_p = GOACC_PROFILING_DISPATCH_P (true); 385 386 acc_prof_info prof_info; 387 if (profiling_p) 388 { 389 thr->prof_info = &prof_info; 390 391 prof_info.event_type = acc_ev_enter_data_start; 392 prof_info.valid_bytes = _ACC_PROF_INFO_VALID_BYTES; 393 prof_info.version = _ACC_PROF_INFO_VERSION; 394 prof_info.device_type = acc_device_type (acc_dev->type); 395 prof_info.device_number = acc_dev->target_id; 396 prof_info.thread_id = -1; 397 prof_info.async = acc_async_sync; /* Always synchronous. */ 398 prof_info.async_queue = prof_info.async; 399 prof_info.src_file = NULL; 400 prof_info.func_name = NULL; 401 prof_info.line_no = -1; 402 prof_info.end_line_no = -1; 403 prof_info.func_line_no = -1; 404 prof_info.func_end_line_no = -1; 405 } 406 acc_event_info enter_data_event_info; 407 if (profiling_p) 408 { 409 enter_data_event_info.other_event.event_type 410 = prof_info.event_type; 411 enter_data_event_info.other_event.valid_bytes 412 = _ACC_OTHER_EVENT_INFO_VALID_BYTES; 413 enter_data_event_info.other_event.parent_construct = acc_construct_data; 414 for (int i = 0; i < mapnum; ++i) 415 if ((kinds[i] & 0xff) == GOMP_MAP_USE_DEVICE_PTR 416 || (kinds[i] & 0xff) == GOMP_MAP_USE_DEVICE_PTR_IF_PRESENT) 417 { 418 /* If there is one such data mapping kind, then this is actually an 419 OpenACC 'host_data' construct. (GCC maps the OpenACC 420 'host_data' construct to the OpenACC 'data' construct.) Apart 421 from artificial test cases (such as an OpenACC 'host_data' 422 construct's (implicit) device initialization when there hasn't 423 been any device data be set up before...), there can't really 424 any meaningful events be generated from OpenACC 'host_data' 425 constructs, though. */ 426 enter_data_event_info.other_event.parent_construct 427 = acc_construct_host_data; 428 break; 429 } 430 enter_data_event_info.other_event.implicit = 0; 431 enter_data_event_info.other_event.tool_info = NULL; 432 } 433 acc_api_info api_info; 434 if (profiling_p) 435 { 436 thr->api_info = &api_info; 437 438 api_info.device_api = acc_device_api_none; 439 api_info.valid_bytes = _ACC_API_INFO_VALID_BYTES; 440 api_info.device_type = prof_info.device_type; 441 api_info.vendor = -1; 442 api_info.device_handle = NULL; 443 api_info.context_handle = NULL; 444 api_info.async_handle = NULL; 445 } 446 447 if (profiling_p) 448 goacc_profiling_dispatch (&prof_info, &enter_data_event_info, &api_info); 449 450 /* Host fallback or 'do nothing'. */ 451 if ((acc_dev->capabilities & GOMP_OFFLOAD_CAP_SHARED_MEM) 452 || (flags & GOACC_FLAG_HOST_FALLBACK)) 453 { 454 prof_info.device_type = acc_device_host; 455 api_info.device_type = prof_info.device_type; 456 tgt = goacc_map_vars (NULL, NULL, 0, NULL, NULL, NULL, NULL, true, 0); 457 tgt->prev = thr->mapped_data; 458 thr->mapped_data = tgt; 459 460 goto out_prof; 461 } 462 463 gomp_debug (0, " %s: prepare mappings\n", __FUNCTION__); 464 tgt = goacc_map_vars (acc_dev, NULL, mapnum, hostaddrs, NULL, sizes, kinds, 465 true, 0); 466 gomp_debug (0, " %s: mappings prepared\n", __FUNCTION__); 467 tgt->prev = thr->mapped_data; 468 thr->mapped_data = tgt; 469 470 out_prof: 471 if (profiling_p) 472 { 473 prof_info.event_type = acc_ev_enter_data_end; 474 enter_data_event_info.other_event.event_type = prof_info.event_type; 475 goacc_profiling_dispatch (&prof_info, &enter_data_event_info, &api_info); 476 477 thr->prof_info = NULL; 478 thr->api_info = NULL; 479 } 480 } 481 482 void 483 GOACC_data_end (void) 484 { 485 struct goacc_thread *thr = goacc_thread (); 486 struct gomp_device_descr *acc_dev = thr->dev; 487 struct target_mem_desc *tgt = thr->mapped_data; 488 489 bool profiling_p = GOACC_PROFILING_DISPATCH_P (true); 490 491 acc_prof_info prof_info; 492 if (profiling_p) 493 { 494 thr->prof_info = &prof_info; 495 496 prof_info.event_type = acc_ev_exit_data_start; 497 prof_info.valid_bytes = _ACC_PROF_INFO_VALID_BYTES; 498 prof_info.version = _ACC_PROF_INFO_VERSION; 499 prof_info.device_type = acc_device_type (acc_dev->type); 500 prof_info.device_number = acc_dev->target_id; 501 prof_info.thread_id = -1; 502 prof_info.async = acc_async_sync; /* Always synchronous. */ 503 prof_info.async_queue = prof_info.async; 504 prof_info.src_file = NULL; 505 prof_info.func_name = NULL; 506 prof_info.line_no = -1; 507 prof_info.end_line_no = -1; 508 prof_info.func_line_no = -1; 509 prof_info.func_end_line_no = -1; 510 } 511 acc_event_info exit_data_event_info; 512 if (profiling_p) 513 { 514 exit_data_event_info.other_event.event_type 515 = prof_info.event_type; 516 exit_data_event_info.other_event.valid_bytes 517 = _ACC_OTHER_EVENT_INFO_VALID_BYTES; 518 exit_data_event_info.other_event.parent_construct = acc_construct_data; 519 exit_data_event_info.other_event.implicit = 0; 520 exit_data_event_info.other_event.tool_info = NULL; 521 } 522 acc_api_info api_info; 523 if (profiling_p) 524 { 525 thr->api_info = &api_info; 526 527 api_info.device_api = acc_device_api_none; 528 api_info.valid_bytes = _ACC_API_INFO_VALID_BYTES; 529 api_info.device_type = prof_info.device_type; 530 api_info.vendor = -1; 531 api_info.device_handle = NULL; 532 api_info.context_handle = NULL; 533 api_info.async_handle = NULL; 534 } 535 536 if (profiling_p) 537 goacc_profiling_dispatch (&prof_info, &exit_data_event_info, &api_info); 538 539 gomp_debug (0, " %s: restore mappings\n", __FUNCTION__); 540 thr->mapped_data = tgt->prev; 541 goacc_unmap_vars (tgt, true, NULL); 542 gomp_debug (0, " %s: mappings restored\n", __FUNCTION__); 543 544 if (profiling_p) 545 { 546 prof_info.event_type = acc_ev_exit_data_end; 547 exit_data_event_info.other_event.event_type = prof_info.event_type; 548 goacc_profiling_dispatch (&prof_info, &exit_data_event_info, &api_info); 549 550 thr->prof_info = NULL; 551 thr->api_info = NULL; 552 } 553 } 554 555 void 556 GOACC_update (int flags_m, size_t mapnum, 557 void **hostaddrs, size_t *sizes, unsigned short *kinds, 558 int async, int num_waits, ...) 559 { 560 int flags = GOACC_FLAGS_UNMARSHAL (flags_m); 561 562 size_t i; 563 564 goacc_lazy_initialize (); 565 566 struct goacc_thread *thr = goacc_thread (); 567 struct gomp_device_descr *acc_dev = thr->dev; 568 569 bool profiling_p = GOACC_PROFILING_DISPATCH_P (true); 570 571 acc_prof_info prof_info; 572 if (profiling_p) 573 { 574 thr->prof_info = &prof_info; 575 576 prof_info.event_type = acc_ev_update_start; 577 prof_info.valid_bytes = _ACC_PROF_INFO_VALID_BYTES; 578 prof_info.version = _ACC_PROF_INFO_VERSION; 579 prof_info.device_type = acc_device_type (acc_dev->type); 580 prof_info.device_number = acc_dev->target_id; 581 prof_info.thread_id = -1; 582 prof_info.async = async; 583 prof_info.async_queue = prof_info.async; 584 prof_info.src_file = NULL; 585 prof_info.func_name = NULL; 586 prof_info.line_no = -1; 587 prof_info.end_line_no = -1; 588 prof_info.func_line_no = -1; 589 prof_info.func_end_line_no = -1; 590 } 591 acc_event_info update_event_info; 592 if (profiling_p) 593 { 594 update_event_info.other_event.event_type 595 = prof_info.event_type; 596 update_event_info.other_event.valid_bytes 597 = _ACC_OTHER_EVENT_INFO_VALID_BYTES; 598 update_event_info.other_event.parent_construct = acc_construct_update; 599 update_event_info.other_event.implicit = 0; 600 update_event_info.other_event.tool_info = NULL; 601 } 602 acc_api_info api_info; 603 if (profiling_p) 604 { 605 thr->api_info = &api_info; 606 607 api_info.device_api = acc_device_api_none; 608 api_info.valid_bytes = _ACC_API_INFO_VALID_BYTES; 609 api_info.device_type = prof_info.device_type; 610 api_info.vendor = -1; 611 api_info.device_handle = NULL; 612 api_info.context_handle = NULL; 613 api_info.async_handle = NULL; 614 } 615 616 if (profiling_p) 617 goacc_profiling_dispatch (&prof_info, &update_event_info, &api_info); 618 619 if ((acc_dev->capabilities & GOMP_OFFLOAD_CAP_SHARED_MEM) 620 || (flags & GOACC_FLAG_HOST_FALLBACK)) 621 { 622 prof_info.device_type = acc_device_host; 623 api_info.device_type = prof_info.device_type; 624 625 goto out_prof; 626 } 627 628 if (num_waits) 629 { 630 va_list ap; 631 632 va_start (ap, num_waits); 633 goacc_wait (async, num_waits, &ap); 634 va_end (ap); 635 } 636 637 bool update_device = false; 638 for (i = 0; i < mapnum; ++i) 639 { 640 unsigned char kind = kinds[i] & 0xff; 641 642 switch (kind) 643 { 644 case GOMP_MAP_POINTER: 645 case GOMP_MAP_TO_PSET: 646 break; 647 648 case GOMP_MAP_ALWAYS_POINTER: 649 if (update_device) 650 { 651 /* Save the contents of the host pointer. */ 652 void *dptr = acc_deviceptr (hostaddrs[i-1]); 653 uintptr_t t = *(uintptr_t *) hostaddrs[i]; 654 655 /* Update the contents of the host pointer to reflect 656 the value of the allocated device memory in the 657 previous pointer. */ 658 *(uintptr_t *) hostaddrs[i] = (uintptr_t)dptr; 659 /* TODO: verify that we really cannot use acc_update_device_async 660 here. */ 661 acc_update_device (hostaddrs[i], sizeof (uintptr_t)); 662 663 /* Restore the host pointer. */ 664 *(uintptr_t *) hostaddrs[i] = t; 665 update_device = false; 666 } 667 break; 668 669 case GOMP_MAP_TO: 670 if (!acc_is_present (hostaddrs[i], sizes[i])) 671 { 672 update_device = false; 673 break; 674 } 675 /* Fallthru */ 676 case GOMP_MAP_FORCE_TO: 677 update_device = true; 678 acc_update_device_async (hostaddrs[i], sizes[i], async); 679 break; 680 681 case GOMP_MAP_FROM: 682 if (!acc_is_present (hostaddrs[i], sizes[i])) 683 { 684 update_device = false; 685 break; 686 } 687 /* Fallthru */ 688 case GOMP_MAP_FORCE_FROM: 689 update_device = false; 690 acc_update_self_async (hostaddrs[i], sizes[i], async); 691 break; 692 693 default: 694 gomp_fatal (">>>> GOACC_update UNHANDLED kind 0x%.2x", kind); 695 break; 696 } 697 } 698 699 out_prof: 700 if (profiling_p) 701 { 702 prof_info.event_type = acc_ev_update_end; 703 update_event_info.other_event.event_type = prof_info.event_type; 704 goacc_profiling_dispatch (&prof_info, &update_event_info, &api_info); 705 706 thr->prof_info = NULL; 707 thr->api_info = NULL; 708 } 709 } 710 711 712 /* Legacy entry point (GCC 5). */ 713 714 int 715 GOACC_get_num_threads (void) 716 { 717 return 1; 718 } 719 720 /* Legacy entry point (GCC 5). */ 721 722 int 723 GOACC_get_thread_num (void) 724 { 725 return 0; 726 } 727
Indexes created Fri Apr 10 00:22:58 UTC 2026