projects / gcc.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
history | raw | HEAD
Fortran] Use proper type for hidden is-present argument
[gcc.git] / liboffloadmic / runtime / offload_omp_host.cpp
1 /*
2 Copyright (c) 2014-2016 Intel Corporation. All Rights Reserved.
3
4 Redistribution and use in source and binary forms, with or without
5 modification, are permitted provided that the following conditions
6 are met:
7
8 * Redistributions of source code must retain the above copyright
9 notice, this list of conditions and the following disclaimer.
10 * Redistributions in binary form must reproduce the above copyright
11 notice, this list of conditions and the following disclaimer in the
12 documentation and/or other materials provided with the distribution.
13 * Neither the name of Intel Corporation nor the names of its
14 contributors may be used to endorse or promote products derived
15 from this software without specific prior written permission.
16
17 THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
18 "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
19 LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
20 A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
21 HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
22 SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
23 LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
24 DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
25 THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
26 (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
27 OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
28 */
29
30
31 #include <omp.h>
32 //#include <stdlib.h>
33 //#include "offload.h"
34 #include "compiler_if_host.h"
35
36
37 // OpenMP API
38
39 void omp_set_default_device(int num) __GOMP_NOTHROW
40 {
41 if (num >= 0) {
42 __omp_device_num = num;
43 }
44 }
45
46 int omp_get_default_device(void) __GOMP_NOTHROW
47 {
48 return __omp_device_num;
49 }
50
51 int omp_get_num_devices() __GOMP_NOTHROW
52 {
53 __offload_init_library();
54 return mic_engines_total;
55 }
56
57 // OpenMP 4.5 APIs
58
59 // COI supports 3-dim multiD transfers
60 #define MAX_ARRAY_RANK 3
61
62 int omp_get_initial_device(
63 void
64 ) __GOMP_NOTHROW
65 {
66 return -1;
67 }
68
69 void* omp_target_alloc(
70 size_t size,
71 int device_num
72 ) __GOMP_NOTHROW
73 {
74 __offload_init_library();
75
76 OFFLOAD_TRACE(2, "omp_target_alloc(%lld, %d)\n", size, device_num);
77
78 if (device_num < -1) {
79 LIBOFFLOAD_ERROR(c_invalid_device_number);
80 exit(1);
81 }
82
83 void* result = 0;
84
85 // malloc on CPU
86 if (device_num == -1) {
87 // We do not check for malloc returning NULL because the
88 // specification of this API includes the possibility of failure.
89 // The user will check the returned result
90 result = malloc(size);
91 return result;
92 }
93
94 OFFLOAD ofld = OFFLOAD_TARGET_ACQUIRE(
95 TARGET_MIC, device_num, 0, NULL, __func__, 0);
96 if (ofld != 0) {
97 VarDesc vars[2] = {0};
98
99 vars[0].type.src = c_data;
100 vars[0].type.dst = c_data;
101 vars[0].direction.bits = c_parameter_in;
102 vars[0].size = sizeof(size);
103 vars[0].count = 1;
104 vars[0].ptr = &size;
105
106 vars[1].type.src = c_data;
107 vars[1].type.dst = c_data;
108 vars[1].direction.bits = c_parameter_out;
109 vars[1].size = sizeof(result);
110 vars[1].count = 1;
111 vars[1].ptr = &result;
112
113 OFFLOAD_OFFLOAD(ofld, "omp_target_alloc_target",
114 0, 2, vars, NULL, 0, 0, 0);
115 }
116 return result;
117 }
118
119 void omp_target_free(
120 void *device_ptr,
121 int device_num
122 ) __GOMP_NOTHROW
123 {
124 __offload_init_library();
125
126 OFFLOAD_TRACE(2, "omp_target_free(%p, %d)\n", device_ptr, device_num);
127
128 if (device_num < -1) {
129 LIBOFFLOAD_ERROR(c_invalid_device_number);
130 exit(1);
131 }
132
133 // free on CPU
134 if (device_num == -1) {
135 free(device_ptr);
136 return;
137 }
138
139 OFFLOAD ofld = OFFLOAD_TARGET_ACQUIRE(
140 TARGET_MIC, device_num, 0, NULL, __func__, 0);
141 if (ofld) {
142 VarDesc vars[1] = {0};
143
144 vars[0].type.src = c_data;
145 vars[0].type.dst = c_data;
146 vars[0].direction.bits = c_parameter_in;
147 vars[0].size = sizeof(device_ptr);
148 vars[0].count = 1;
149 vars[0].ptr = &device_ptr;
150
151 OFFLOAD_OFFLOAD(ofld, "omp_target_free_target",
152 0, 1, vars, NULL, 0, 0, 0);
153 }
154 }
155
156 int omp_target_is_present(
157 void *ptr,
158 int device_num
159 ) __GOMP_NOTHROW
160 {
161 __offload_init_library();
162
163 OFFLOAD_TRACE(2, "omp_target_is_present(%p, %d)\n", ptr, device_num);
164
165 if (device_num < -1) {
166 LIBOFFLOAD_ERROR(c_invalid_device_number);
167 exit(1);
168 }
169
170 if (device_num == -1) {
171 return false;
172 }
173
174 // If OpenMP allows wrap-around for device numbers, enable next line
175 //device_num %= mic_engines_total;
176
177 // lookup existing association in pointer table
178 PtrData* ptr_data = mic_engines[device_num].find_ptr_data(ptr);
179 if (ptr_data == 0) {
180 OFFLOAD_TRACE(3, "Address %p is not mapped on device %d\n",
181 ptr, device_num);
182 return false;
183 }
184
185 OFFLOAD_TRACE(3, "Address %p found mapped on device %d\n",
186 ptr, device_num);
187 return true;
188 }
189
190 int omp_target_memcpy(
191 void *dst,
192 void *src,
193 size_t length,
194 size_t dst_offset,
195 size_t src_offset,
196 int dst_device,
197 int src_device
198 ) __GOMP_NOTHROW
199 {
200 __offload_init_library();
201
202 OFFLOAD_TRACE(2, "omp_target_memcpy(%p, %p, %lld, %lld, %lld, %d, %d)\n",
203 dst, src, length, dst_offset, src_offset, dst_device, src_device);
204
205 if (dst_device < -1 || src_device < -1) {
206 LIBOFFLOAD_ERROR(c_invalid_device_number);
207 exit(1);
208 }
209
210 char* srcp = (char *)src + src_offset;
211 char* dstp = (char *)dst + dst_offset;
212
213 if (src_device == -1) {
214 // Source is CPU
215 if (dst_device == -1) {
216 // CPU -> CPU
217 memcpy(dstp, srcp, length);
218 return 0;
219 } else {
220 // CPU -> MIC
221 // COIBufferWrite
222 // If OpenMP allows wrap-around for device numbers, enable next line
223 //dst_device %= mic_engines_total;
224
225 OFFLOAD_TRACE(3, "Creating buffer from sink memory %llx\n", dstp);
226 COIBUFFER mic_buf;
227 COIRESULT res = COI::BufferCreateFromMemory(length,
228 COI_BUFFER_NORMAL, COI_SINK_MEMORY, dstp,
229 1, &mic_engines[dst_device].get_process(),
230 &mic_buf);
231 if (res != COI_SUCCESS) {
232 LIBOFFLOAD_ERROR(c_buf_create_from_mem, res);
233 return 1;
234 }
235 res = COI::BufferWrite(mic_buf, 0, srcp, length,
236 COI_COPY_UNSPECIFIED, 0, 0, 0);
237 if (res != COI_SUCCESS) {
238 LIBOFFLOAD_ERROR(c_buf_write, res);
239 return 1;
240 }
241 res = COI::BufferDestroy(mic_buf);
242 if (res != COI_SUCCESS) {
243 LIBOFFLOAD_ERROR(c_buf_destroy, res);
244 return 1;
245 }
246 return 0;
247 }
248 } else {
249 // Source is device
250 if (dst_device == -1) {
251 // MIC -> CPU
252 // COIBufferRead
253
254 // If OpenMP allows wrap-around for device numbers, enable next line
255 //src_device %= mic_engines_total;
256
257 OFFLOAD_TRACE(3, "Creating buffer from sink memory %llx\n", srcp);
258 COIBUFFER mic_buf;
259 COIRESULT res = COI::BufferCreateFromMemory(length,
260 COI_BUFFER_NORMAL, COI_SINK_MEMORY, srcp,
261 1, &mic_engines[src_device].get_process(),
262 &mic_buf);
263 if (res != COI_SUCCESS) {
264 LIBOFFLOAD_ERROR(c_buf_create_from_mem, res);
265 return 1;
266 }
267 res = COI::BufferRead(mic_buf, 0, dstp, length,
268 COI_COPY_UNSPECIFIED, 0, 0, 0);
269 if (res != COI_SUCCESS) {
270 LIBOFFLOAD_ERROR(c_buf_read, res);
271 return 1;
272 }
273 res = COI::BufferDestroy(mic_buf);
274 if (res != COI_SUCCESS) {
275 LIBOFFLOAD_ERROR(c_buf_destroy, res);
276 return 1;
277 }
278 return 0;
279 } else {
280 // some MIC -> some MIC
281 if (src_device == dst_device) {
282 // MIC local copy will be done as remote memcpy
283
284 OFFLOAD ofld = OFFLOAD_TARGET_ACQUIRE(TARGET_MIC, src_device,
285 0, NULL, __func__, 0);
286 if (ofld) {
287 VarDesc vars[3] = {0};
288
289 vars[0].type.src = c_data;
290 vars[0].type.dst = c_data;
291 vars[0].direction.bits = c_parameter_in;
292 vars[0].size = sizeof(dstp);
293 vars[0].count = 1;
294 vars[0].ptr = &dstp;
295
296 vars[1].type.src = c_data;
297 vars[1].type.dst = c_data;
298 vars[1].direction.bits = c_parameter_in;
299 vars[1].size = sizeof(srcp);
300 vars[1].count = 1;
301 vars[1].ptr = &srcp;
302
303 vars[2].type.src = c_data;
304 vars[2].type.dst = c_data;
305 vars[2].direction.bits = c_parameter_in;
306 vars[2].size = sizeof(length);
307 vars[2].count = 1;
308 vars[2].ptr = &length;
309
310 OFFLOAD_OFFLOAD(ofld, "omp_target_memcpy_target",
311 0, 3, vars, NULL, 0, 0, 0);
312 return 0;
313 } else {
314 return 1;
315 }
316 } else {
317 // MICx -> MICy
318 // Allocate CPU buffer
319 char *cpu_mem = (char *)malloc(length);
320 if (cpu_mem == 0) {
321 LIBOFFLOAD_ERROR(c_malloc);
322 return 1;
323 }
324 int retval = 1;
325 if (omp_target_memcpy(
326 cpu_mem, srcp, length, 0, 0, -1, src_device) == 0) {
327 retval = omp_target_memcpy(
328 dstp, cpu_mem, length, 0, 0, dst_device, -1);
329 }
330 free(cpu_mem);
331 return retval;
332 }
333 }
334 }
335 }
336
337 static size_t bytesize_at_this_dimension(
338 size_t element_size,
339 int num_dims,
340 const size_t* dimensions
341 )
342 {
343 if (num_dims > 1) {
344 return dimensions[1] *
345 bytesize_at_this_dimension(
346 element_size, num_dims-1, dimensions+1);
347 } else {
348 return element_size;
349 }
350 }
351
352 static void memcpy_rect(
353 char *dst,
354 char *src,
355 size_t element_size,
356 int num_dims,
357 const size_t *volume,
358 const size_t *dst_offsets,
359 const size_t *src_offsets,
360 const size_t *dst_dimensions,
361 const size_t *src_dimensions
362 )
363 {
364 if (num_dims > 1) {
365 int count = volume[0];
366 int dst_index = dst_offsets[0];
367 int src_index = src_offsets[0];
368 size_t dst_element_size =
369 bytesize_at_this_dimension(element_size, num_dims, dst_dimensions);
370 size_t src_element_size =
371 bytesize_at_this_dimension(element_size, num_dims, src_dimensions);
372 for (; count>0; dst_index++, src_index++, count--) {
373 memcpy_rect(dst+dst_element_size*dst_index,
374 src+src_element_size*src_index,
375 element_size, num_dims-1, volume+1,
376 dst_offsets+1, src_offsets+1,
377 dst_dimensions+1, src_dimensions+1);
378 }
379 } else {
380 memcpy(dst+dst_offsets[0]*element_size,
381 src+src_offsets[0]*element_size,
382 element_size * volume[0]);
383 }
384 }
385
386 int omp_target_memcpy_rect(
387 void *dst_,
388 void *src_,
389 size_t element_size,
390 int num_dims,
391 const size_t *volume,
392 const size_t *dst_offsets,
393 const size_t *src_offsets,
394 const size_t *dst_dimensions,
395 const size_t *src_dimensions,
396 int dst_device,
397 int src_device
398 ) __GOMP_NOTHROW
399 {
400 char *dst = (char *)dst_;
401 char *src = (char *)src_;
402
403 __offload_init_library();
404
405 OFFLOAD_TRACE(2, "omp_target_memcpy_rect(%p, %p, %lld, %d, "
406 "%p, %p, %p, %p, %p, %d, %d)\n",
407 dst, src, element_size, num_dims,
408 volume, dst_offsets, src_offsets,
409 dst_dimensions, src_dimensions, dst_device, src_device);
410
411 // MAX_ARRAY_RANK dimensions are supported
412 if (dst == 0 && src == 0) {
413 return MAX_ARRAY_RANK;
414 }
415
416 if (num_dims < 1 || num_dims > MAX_ARRAY_RANK ||
417 element_size < 1 ||
418 volume == 0 || dst_offsets == 0 || src_offsets == 0 ||
419 dst_dimensions == 0 || src_dimensions == 0) {
420 return 1;
421 }
422
423 if (dst_device < -1 || src_device < -1) {
424 LIBOFFLOAD_ERROR(c_invalid_device_number);
425 exit(1);
426 }
427
428 if (src_device == -1) {
429 // Source is CPU
430 if (dst_device == -1) {
431 // CPU -> CPU
432 memcpy_rect((char*)dst, (char*)src, element_size, num_dims, volume,
433 dst_offsets, src_offsets,
434 dst_dimensions, src_dimensions);
435 return 0;
436 } else {
437 // CPU -> MIC
438 // COIBufferWriteMultiD
439 struct arr_desc dst_desc;
440 struct arr_desc src_desc;
441
442 dst_desc.base = (int64_t)dst;
443 dst_desc.rank = num_dims;
444
445 src_desc.base = (int64_t)src;
446 src_desc.rank = num_dims;
447
448 for (int i=0; i<num_dims; i++)
449 {
450 dst_desc.dim[i].size = bytesize_at_this_dimension(
451 element_size,
452 num_dims - i,
453 dst_dimensions + i);
454 dst_desc.dim[i].lindex = 0;
455 dst_desc.dim[i].lower = dst_offsets[i];
456 dst_desc.dim[i].upper = dst_offsets[i] + volume[i] - 1;
457 dst_desc.dim[i].stride = 1;
458
459 src_desc.dim[i].size = bytesize_at_this_dimension(
460 element_size,
461 num_dims - i,
462 src_dimensions + i);
463 src_desc.dim[i].lindex = 0;
464 src_desc.dim[i].lower = src_offsets[i];
465 src_desc.dim[i].upper = src_offsets[i] + volume[i] - 1;
466 src_desc.dim[i].stride = 1;
467 }
468 __arr_desc_dump("", "dst", (const Arr_Desc*)&dst_desc, false, false);
469 __arr_desc_dump("", "src", (const Arr_Desc*)&src_desc, false, false);
470
471 // If OpenMP allows wrap-around for device numbers, enable next line
472 //dst_device %= mic_engines_total;
473
474 // Compute MIC buffer size
475 size_t dst_length = dst_dimensions[0] * bytesize_at_this_dimension(
476 element_size,
477 num_dims,
478 dst_dimensions);
479
480 OFFLOAD_TRACE(3,
481 "Creating buffer from sink memory %llx of size %lld\n",
482 dst, dst_length);
483 COIBUFFER mic_buf;
484 COIRESULT res = COI::BufferCreateFromMemory(dst_length,
485 COI_BUFFER_NORMAL, COI_SINK_MEMORY, dst,
486 1, &mic_engines[dst_device].get_process(),
487 &mic_buf);
488 if (res != COI_SUCCESS) {
489 LIBOFFLOAD_ERROR(c_buf_create_from_mem, res);
490 return 1;
491 }
492 res = COI::BufferWriteMultiD(mic_buf,
493 mic_engines[dst_device].get_process(),
494 0, &dst_desc, &src_desc,
495 COI_COPY_UNSPECIFIED, 0, 0, 0);
496 if (res != COI_SUCCESS) {
497 LIBOFFLOAD_ERROR(c_buf_write, res);
498 return 1;
499 }
500 res = COI::BufferDestroy(mic_buf);
501 if (res != COI_SUCCESS) {
502 LIBOFFLOAD_ERROR(c_buf_destroy, res);
503 return 1;
504 }
505 return 0;
506 }
507 } else {
508 // Source is device
509 if (dst_device == -1) {
510 // COIBufferReadMultiD
511 struct arr_desc dst_desc;
512 struct arr_desc src_desc;
513
514 dst_desc.base = (int64_t)dst;
515 dst_desc.rank = num_dims;
516
517 src_desc.base = (int64_t)src;
518 src_desc.rank = num_dims;
519
520 for (int i=0; i<num_dims; i++)
521 {
522 dst_desc.dim[i].size = bytesize_at_this_dimension(
523 element_size,
524 num_dims - i,
525 dst_dimensions + i);
526 dst_desc.dim[i].lindex = 0;
527 dst_desc.dim[i].lower = dst_offsets[i];
528 dst_desc.dim[i].upper = dst_offsets[i] + volume[i] - 1;
529 dst_desc.dim[i].stride = 1;
530
531 src_desc.dim[i].size = bytesize_at_this_dimension(
532 element_size,
533 num_dims - i,
534 src_dimensions + i);
535 src_desc.dim[i].lindex = 0;
536 src_desc.dim[i].lower = src_offsets[i];
537 src_desc.dim[i].upper = src_offsets[i] + volume[i] - 1;
538 src_desc.dim[i].stride = 1;
539 }
540 __arr_desc_dump("", "dst", (const Arr_Desc*)&dst_desc, false, false);
541 __arr_desc_dump("", "src", (const Arr_Desc*)&src_desc, false, false);
542
543 // If OpenMP allows wrap-around for device numbers, enable next line
544 //src_device %= mic_engines_total;
545
546 // Compute MIC buffer size
547 size_t src_length = src_dimensions[0] * bytesize_at_this_dimension(
548 element_size,
549 num_dims,
550 src_dimensions);
551
552 OFFLOAD_TRACE(3,
553 "Creating buffer from sink memory %llx of size %lld\n",
554 src, src_length);
555 COIBUFFER mic_buf;
556 COIRESULT res = COI::BufferCreateFromMemory(src_length,
557 COI_BUFFER_NORMAL, COI_SINK_MEMORY, src,
558 1, &mic_engines[src_device].get_process(),
559 &mic_buf);
560 if (res != COI_SUCCESS) {
561 LIBOFFLOAD_ERROR(c_buf_create_from_mem, res);
562 return 1;
563 }
564 res = COI::BufferReadMultiD(mic_buf, 0,
565 &dst_desc, &src_desc,
566 COI_COPY_UNSPECIFIED, 0, 0, 0);
567 if (res != COI_SUCCESS) {
568 LIBOFFLOAD_ERROR(c_buf_write, res);
569 return 1;
570 }
571 res = COI::BufferDestroy(mic_buf);
572 if (res != COI_SUCCESS) {
573 LIBOFFLOAD_ERROR(c_buf_destroy, res);
574 return 1;
575 }
576 return 0;
577 } else {
578 // some MIC -> some MIC
579 if (src_device == dst_device) {
580 // MIC local copy will be done as remote memcpy_rect
581 struct parameters {
582 void *dst;
583 void *src;
584 size_t element_size;
585 int num_dims;
586 size_t array_info[MAX_ARRAY_RANK*5];
587 } parameters = {dst, src, element_size, num_dims};
588 int result;
589
590 for (int i=0; i<num_dims; i++)
591 {
592 parameters.array_info[i] = volume[i];
593 parameters.array_info[i+num_dims] = dst_offsets[i];
594 parameters.array_info[i+num_dims*2] = src_offsets[i];
595 parameters.array_info[i+num_dims*3] = dst_dimensions[i];
596 parameters.array_info[i+num_dims*4] = src_dimensions[i];
597 }
598
599 OFFLOAD ofld = OFFLOAD_TARGET_ACQUIRE(TARGET_MIC, src_device,
600 0, NULL, __func__, 0);
601 if (ofld) {
602 VarDesc vars[1] = {0};
603
604 vars[0].type.src = c_data;
605 vars[0].type.dst = c_data;
606 vars[0].direction.bits = c_parameter_in;
607 vars[0].size = sizeof(parameters) -
608 (MAX_ARRAY_RANK - num_dims) *
609 5 * sizeof(size_t);
610 vars[0].count = 1;
611 vars[0].ptr = &parameters;
612
613 OFFLOAD_OFFLOAD(ofld, "omp_target_memcpy_rect_target",
614 0, 1, vars, NULL, 0, 0, 0);
615 return 0;
616 } else {
617 return 1;
618 }
619 } else {
620 // MICx -> MICy
621
622 // Compute transfer byte-count
623 size_t dst_length = element_size;
624 for (int i=0; i<num_dims; i++) {
625 dst_length *= volume[i];
626 }
627
628 // Allocate CPU buffer
629 char *cpu_mem = (char *)malloc(dst_length);
630 if (cpu_mem == 0) {
631 LIBOFFLOAD_ERROR(c_malloc);
632 return 1;
633 }
634
635 // Create CPU offset and dimension arrays
636 // The CPU array collects the data in a contiguous block
637 size_t cpu_offsets[MAX_ARRAY_RANK];
638 size_t cpu_dimensions[MAX_ARRAY_RANK];
639 for (int i=0; i<num_dims; i++) {
640 cpu_offsets[i] = 0;
641 cpu_dimensions[i] = volume[i];
642 }
643
644 int retval = 1;
645 if (omp_target_memcpy_rect(
646 cpu_mem, src, element_size, num_dims, volume,
647 cpu_offsets, src_offsets,
648 cpu_dimensions, src_dimensions,
649 -1, src_device) == 0) {
650 retval = omp_target_memcpy_rect(
651 dst, cpu_mem, element_size, num_dims, volume,
652 dst_offsets, cpu_offsets,
653 dst_dimensions, cpu_dimensions,
654 dst_device, -1);
655 }
656 free(cpu_mem);
657 return retval;
658 }
659 }
660 }
661 }
662
663 // host_ptr is key in table that yields association on device
664 // A COIBUFFER of specified size is created from the memory at
665 // device_ptr+device_offset on device_num
666 int omp_target_associate_ptr(
667 void *host_ptr,
668 void *device_ptr,
669 size_t size,
670 size_t device_offset,
671 int device_num
672 ) __GOMP_NOTHROW
673 {
674 COIRESULT res;
675
676 __offload_init_library();
677
678 OFFLOAD_TRACE(2, "omp_target_associate_ptr(%p, %p, %lld, %lld, %d)\n",
679 host_ptr, device_ptr, size, device_offset, device_num);
680
681 if (device_num < -1) {
682 LIBOFFLOAD_ERROR(c_invalid_device_number);
683 exit(1);
684 }
685
686 // Associating to CPU is treated as failure
687 if (device_num == -1) {
688 return 1;
689 }
690
691 // An incorrect size is treated as failure
692 if (size < 0) {
693 return 1;
694 }
695
696 // If OpenMP allows wrap-around for device numbers, enable next line
697 //Engine& device = mic_engines[device_num % mic_engines_total];
698 Engine& device = mic_engines[device_num];
699
700 // Does host pointer have association already?
701 // lookup existing association in pointer table
702 PtrData* ptr_data = device.find_ptr_data(host_ptr);
703 if (ptr_data != 0) {
704 OFFLOAD_TRACE(3, "Address %p is already mapped on device %d\n",
705 host_ptr, device_num);
706 // Is current device pointer and offset same as existing?
707 if ((void*)ptr_data->mic_addr == device_ptr &&
708 (size_t)ptr_data->alloc_disp == device_offset) {
709 return 0;
710 } else {
711 return 1;
712 }
713 }
714
715 // Create association
716 OFFLOAD_TRACE(3, "Creating association for data: addr %p, length %lld\n",
717 host_ptr, size);
718
719 bool is_new;
720 ptr_data = device.insert_ptr_data(host_ptr, size, is_new);
721 ptr_data->is_omp_associate = true;
722
723 // create CPU buffer
724 OFFLOAD_TRACE(3,
725 "Creating buffer from source memory %p, length %lld\n",
726 host_ptr, size);
727
728 // result is not checked because we can continue without cpu
729 // buffer. In this case we will use COIBufferRead/Write
730 // instead of COIBufferCopy.
731
732 COI::BufferCreateFromMemory(size,
733 COI_BUFFER_OPENCL,
734 0,
735 host_ptr,
736 1,
737 &device.get_process(),
738 &ptr_data->cpu_buf);
739
740 // create MIC buffer
741 OFFLOAD_TRACE(3,
742 "Creating buffer from sink memory: addr %p, size %lld\n",
743 (char *)device_ptr + device_offset, size);
744 res = COI::BufferCreateFromMemory(size,
745 COI_BUFFER_NORMAL,
746 COI_SINK_MEMORY,
747 device_ptr,
748 1,
749 &device.get_process(),
750 &ptr_data->mic_buf);
751 if (res != COI_SUCCESS) {
752 ptr_data->alloc_ptr_data_lock.unlock();
753 return 1;
754 }
755
756 // make buffer valid on the device.
757 res = COI::BufferSetState(ptr_data->mic_buf,
758 device.get_process(),
759 COI_BUFFER_VALID,
760 COI_BUFFER_NO_MOVE,
761 0, 0, 0);
762 if (res != COI_SUCCESS) {
763 ptr_data->alloc_ptr_data_lock.unlock();
764 return 1;
765 }
766
767 res = COI::BufferSetState(ptr_data->mic_buf,
768 COI_PROCESS_SOURCE,
769 COI_BUFFER_INVALID,
770 COI_BUFFER_NO_MOVE,
771 0, 0, 0);
772 if (res != COI_SUCCESS) {
773 ptr_data->alloc_ptr_data_lock.unlock();
774 return 1;
775 }
776 ptr_data->alloc_disp = device_offset;
777 ptr_data->alloc_ptr_data_lock.unlock();
778
779 return 0;
780 }
781
782 int omp_target_disassociate_ptr(
783 void *host_ptr,
784 int device_num
785 ) __GOMP_NOTHROW
786 {
787 COIRESULT res;
788
789 __offload_init_library();
790
791 OFFLOAD_TRACE(2, "omp_target_disassociate_ptr(%p, %d)\n",
792 host_ptr, device_num);
793
794 if (device_num < -1) {
795 LIBOFFLOAD_ERROR(c_invalid_device_number);
796 exit(1);
797 }
798
799 // Dissociating from CPU is treated as failure
800 if (device_num == -1) {
801 return 1;
802 }
803
804 // If OpenMP allows wrap-around for device numbers, enable next line
805 //Engine& device = mic_engines[device_num % mic_engines_total];
806 Engine& device = mic_engines[device_num];
807
808 // Lookup existing association in pointer table
809 PtrData* ptr_data = device.find_ptr_data(host_ptr);
810
811 // Attempt to disassociate unassociated pointer is a failure
812 if (ptr_data == 0) {
813 return 1;
814 }
815
816 // Destroy buffers
817 if (ptr_data->cpu_buf != 0) {
818 OFFLOAD_TRACE(3, "Destroying CPU buffer %p\n", ptr_data->cpu_buf);
819 COI::BufferDestroy(ptr_data->cpu_buf);
820 }
821 if (ptr_data->mic_buf != 0) {
822 OFFLOAD_TRACE(3, "Destroying MIC buffer %p\n", ptr_data->mic_buf);
823 COI::BufferDestroy(ptr_data->mic_buf);
824 }
825
826 // Remove association from map
827 OFFLOAD_TRACE(3, "Removing association for addr %p\n",
828 ptr_data->cpu_addr.start());
829 device.remove_ptr_data(ptr_data->cpu_addr.start());
830
831 return 0;
832 }
833
834 // End of OpenMP 4.5 APIs
835
836
837 // OpenMP API wrappers
838
839 static void omp_set_int_target(
840 TARGET_TYPE target_type,
841 int target_number,
842 int setting,
843 const char* f_name
844 )
845 {
846 OFFLOAD ofld = OFFLOAD_TARGET_ACQUIRE(target_type, target_number, 0, NULL,
847 f_name, 0);
848 if (ofld) {
849 VarDesc vars[1] = {0};
850
851 vars[0].type.src = c_data;
852 vars[0].type.dst = c_data;
853 vars[0].direction.bits = c_parameter_in;
854 vars[0].size = sizeof(int);
855 vars[0].count = 1;
856 vars[0].ptr = &setting;
857
858 OFFLOAD_OFFLOAD(ofld, f_name, 0, 1, vars, NULL, 0, 0, 0);
859 }
860 }
861
862 static int omp_get_int_target(
863 TARGET_TYPE target_type,
864 int target_number,
865 const char * f_name
866 )
867 {
868 int setting = 0;
869
870 OFFLOAD ofld = OFFLOAD_TARGET_ACQUIRE(target_type, target_number, 0, NULL,
871 f_name, 0);
872 if (ofld) {
873 VarDesc vars[1] = {0};
874
875 vars[0].type.src = c_data;
876 vars[0].type.dst = c_data;
877 vars[0].direction.bits = c_parameter_out;
878 vars[0].size = sizeof(int);
879 vars[0].count = 1;
880 vars[0].ptr = &setting;
881
882 OFFLOAD_OFFLOAD(ofld, f_name, 0, 1, vars, NULL, 0, 0, 0);
883 }
884 return setting;
885 }
886
887 void omp_set_num_threads_target(
888 TARGET_TYPE target_type,
889 int target_number,
890 int num_threads
891 )
892 {
893 omp_set_int_target(target_type, target_number, num_threads,
894 "omp_set_num_threads_target");
895 }
896
897 int omp_get_max_threads_target(
898 TARGET_TYPE target_type,
899 int target_number
900 )
901 {
902 return omp_get_int_target(target_type, target_number,
903 "omp_get_max_threads_target");
904 }
905
906 int omp_get_num_procs_target(
907 TARGET_TYPE target_type,
908 int target_number
909 )
910 {
911 return omp_get_int_target(target_type, target_number,
912 "omp_get_num_procs_target");
913 }
914
915 void omp_set_dynamic_target(
916 TARGET_TYPE target_type,
917 int target_number,
918 int num_threads
919 )
920 {
921 omp_set_int_target(target_type, target_number, num_threads,
922 "omp_set_dynamic_target");
923 }
924
925 int omp_get_dynamic_target(
926 TARGET_TYPE target_type,
927 int target_number
928 )
929 {
930 return omp_get_int_target(target_type, target_number,
931 "omp_get_dynamic_target");
932 }
933
934 void omp_set_nested_target(
935 TARGET_TYPE target_type,
936 int target_number,
937 int nested
938 )
939 {
940 omp_set_int_target(target_type, target_number, nested,
941 "omp_set_nested_target");
942 }
943
944 int omp_get_nested_target(
945 TARGET_TYPE target_type,
946 int target_number
947 )
948 {
949 return omp_get_int_target(target_type, target_number,
950 "omp_get_nested_target");
951 }
952
953 void omp_set_schedule_target(
954 TARGET_TYPE target_type,
955 int target_number,
956 omp_sched_t kind,
957 int modifier
958 )
959 {
960 OFFLOAD ofld = OFFLOAD_TARGET_ACQUIRE(target_type, target_number, 0, NULL,
961 __func__, 0);
962 if (ofld != 0) {
963 VarDesc vars[2] = {0};
964
965 vars[0].type.src = c_data;
966 vars[0].type.dst = c_data;
967 vars[0].direction.bits = c_parameter_in;
968 vars[0].size = sizeof(omp_sched_t);
969 vars[0].count = 1;
970 vars[0].ptr = &kind;
971
972 vars[1].type.src = c_data;
973 vars[1].type.dst = c_data;
974 vars[1].direction.bits = c_parameter_in;
975 vars[1].size = sizeof(int);
976 vars[1].count = 1;
977 vars[1].ptr = &modifier;
978
979 OFFLOAD_OFFLOAD(ofld, "omp_set_schedule_target",
980 0, 2, vars, NULL, 0, 0, 0);
981 }
982 }
983
984 void omp_get_schedule_target(
985 TARGET_TYPE target_type,
986 int target_number,
987 omp_sched_t *kind,
988 int *modifier
989 )
990 {
991 OFFLOAD ofld = OFFLOAD_TARGET_ACQUIRE(target_type, target_number, 0, NULL,
992 __func__, 0);
993 if (ofld != 0) {
994 VarDesc vars[2] = {0};
995
996 vars[0].type.src = c_data;
997 vars[0].type.dst = c_data;
998 vars[0].direction.bits = c_parameter_out;
999 vars[0].size = sizeof(omp_sched_t);
1000 vars[0].count = 1;
1001 vars[0].ptr = kind;
1002
1003 vars[1].type.src = c_data;
1004 vars[1].type.dst = c_data;
1005 vars[1].direction.bits = c_parameter_out;
1006 vars[1].size = sizeof(int);
1007 vars[1].count = 1;
1008 vars[1].ptr = modifier;
1009
1010 OFFLOAD_OFFLOAD(ofld, "omp_get_schedule_target",
1011 0, 2, vars, NULL, 0, 0, 0);
1012 }
1013 }
1014
1015 // lock API functions
1016
1017 void omp_init_lock_target(
1018 TARGET_TYPE target_type,
1019 int target_number,
1020 omp_lock_target_t *lock
1021 )
1022 {
1023 OFFLOAD ofld = OFFLOAD_TARGET_ACQUIRE(target_type, target_number, 0, NULL,
1024 __func__, 0);
1025 if (ofld != 0) {
1026 VarDesc vars[1] = {0};
1027
1028 vars[0].type.src = c_data;
1029 vars[0].type.dst = c_data;
1030 vars[0].direction.bits = c_parameter_out;
1031 vars[0].size = sizeof(omp_lock_target_t);
1032 vars[0].count = 1;
1033 vars[0].ptr = lock;
1034
1035 OFFLOAD_OFFLOAD(ofld, "omp_init_lock_target",
1036 0, 1, vars, NULL, 0, 0, 0);
1037 }
1038 }
1039
1040 void omp_destroy_lock_target(
1041 TARGET_TYPE target_type,
1042 int target_number,
1043 omp_lock_target_t *lock
1044 )
1045 {
1046 OFFLOAD ofld = OFFLOAD_TARGET_ACQUIRE(target_type, target_number, 0, NULL,
1047 __func__, 0);
1048 if (ofld != 0) {
1049 VarDesc vars[1] = {0};
1050
1051 vars[0].type.src = c_data;
1052 vars[0].type.dst = c_data;
1053 vars[0].direction.bits = c_parameter_in;
1054 vars[0].size = sizeof(omp_lock_target_t);
1055 vars[0].count = 1;
1056 vars[0].ptr = lock;
1057
1058 OFFLOAD_OFFLOAD(ofld, "omp_destroy_lock_target",
1059 0, 1, vars, NULL, 0, 0, 0);
1060 }
1061 }
1062
1063 void omp_set_lock_target(
1064 TARGET_TYPE target_type,
1065 int target_number,
1066 omp_lock_target_t *lock
1067 )
1068 {
1069 OFFLOAD ofld = OFFLOAD_TARGET_ACQUIRE(target_type, target_number, 0, NULL,
1070 __func__, 0);
1071 if (ofld != 0) {
1072 VarDesc vars[1] = {0};
1073
1074 vars[0].type.src = c_data;
1075 vars[0].type.dst = c_data;
1076 vars[0].direction.bits = c_parameter_inout;
1077 vars[0].size = sizeof(omp_lock_target_t);
1078 vars[0].count = 1;
1079 vars[0].ptr = lock;
1080
1081 OFFLOAD_OFFLOAD(ofld, "omp_set_lock_target",
1082 0, 1, vars, NULL, 0, 0, 0);
1083 }
1084 }
1085
1086 void omp_unset_lock_target(
1087 TARGET_TYPE target_type,
1088 int target_number,
1089 omp_lock_target_t *lock
1090 )
1091 {
1092 OFFLOAD ofld = OFFLOAD_TARGET_ACQUIRE(target_type, target_number, 0, NULL,
1093 __func__, 0);
1094 if (ofld != 0) {
1095 VarDesc vars[1] = {0};
1096
1097 vars[0].type.src = c_data;
1098 vars[0].type.dst = c_data;
1099 vars[0].direction.bits = c_parameter_inout;
1100 vars[0].size = sizeof(omp_lock_target_t);
1101 vars[0].count = 1;
1102 vars[0].ptr = lock;
1103
1104 OFFLOAD_OFFLOAD(ofld, "omp_unset_lock_target",
1105 0, 1, vars, NULL, 0, 0, 0);
1106 }
1107 }
1108
1109 int omp_test_lock_target(
1110 TARGET_TYPE target_type,
1111 int target_number,
1112 omp_lock_target_t *lock
1113 )
1114 {
1115 int result = 0;
1116
1117 OFFLOAD ofld = OFFLOAD_TARGET_ACQUIRE(target_type, target_number, 0, NULL,
1118 __func__, 0);
1119 if (ofld != 0) {
1120 VarDesc vars[2] = {0};
1121
1122 vars[0].type.src = c_data;
1123 vars[0].type.dst = c_data;
1124 vars[0].direction.bits = c_parameter_inout;
1125 vars[0].size = sizeof(omp_lock_target_t);
1126 vars[0].count = 1;
1127 vars[0].ptr = lock;
1128
1129 vars[1].type.src = c_data;
1130 vars[1].type.dst = c_data;
1131 vars[1].direction.bits = c_parameter_out;
1132 vars[1].size = sizeof(int);
1133 vars[1].count = 1;
1134 vars[1].ptr = &result;
1135
1136 OFFLOAD_OFFLOAD(ofld, "omp_test_lock_target",
1137 0, 2, vars, NULL, 0, 0, 0);
1138 }
1139 return result;
1140 }
1141
1142 // nested lock API functions
1143
1144 void omp_init_nest_lock_target(
1145 TARGET_TYPE target_type,
1146 int target_number,
1147 omp_nest_lock_target_t *lock
1148 )
1149 {
1150 OFFLOAD ofld = OFFLOAD_TARGET_ACQUIRE(target_type, target_number, 0, NULL,
1151 __func__, 0);
1152 if (ofld != 0) {
1153 VarDesc vars[1] = {0};
1154
1155 vars[0].type.src = c_data;
1156 vars[0].type.dst = c_data;
1157 vars[0].direction.bits = c_parameter_out;
1158 vars[0].size = sizeof(omp_nest_lock_target_t);
1159 vars[0].count = 1;
1160 vars[0].ptr = lock;
1161
1162 OFFLOAD_OFFLOAD(ofld, "omp_init_nest_lock_target",
1163 0, 1, vars, NULL, 0, 0, 0);
1164 }
1165 }
1166
1167 void omp_destroy_nest_lock_target(
1168 TARGET_TYPE target_type,
1169 int target_number,
1170 omp_nest_lock_target_t *lock
1171 )
1172 {
1173 OFFLOAD ofld = OFFLOAD_TARGET_ACQUIRE(target_type, target_number, 0, NULL,
1174 __func__, 0);
1175 if (ofld != 0) {
1176 VarDesc vars[1] = {0};
1177
1178 vars[0].type.src = c_data;
1179 vars[0].type.dst = c_data;
1180 vars[0].direction.bits = c_parameter_in;
1181 vars[0].size = sizeof(omp_nest_lock_target_t);
1182 vars[0].count = 1;
1183 vars[0].ptr = lock;
1184
1185 OFFLOAD_OFFLOAD(ofld, "omp_destroy_nest_lock_target",
1186 0, 1, vars, NULL, 0, 0, 0);
1187 }
1188 }
1189
1190 void omp_set_nest_lock_target(
1191 TARGET_TYPE target_type,
1192 int target_number,
1193 omp_nest_lock_target_t *lock
1194 )
1195 {
1196 OFFLOAD ofld = OFFLOAD_TARGET_ACQUIRE(target_type, target_number, 0, NULL,
1197 __func__, 0);
1198 if (ofld != 0) {
1199 VarDesc vars[1] = {0};
1200
1201 vars[0].type.src = c_data;
1202 vars[0].type.dst = c_data;
1203 vars[0].direction.bits = c_parameter_inout;
1204 vars[0].size = sizeof(omp_nest_lock_target_t);
1205 vars[0].count = 1;
1206 vars[0].ptr = lock;
1207
1208 OFFLOAD_OFFLOAD(ofld, "omp_set_nest_lock_target",
1209 0, 1, vars, NULL, 0, 0, 0);
1210 }
1211 }
1212
1213 void omp_unset_nest_lock_target(
1214 TARGET_TYPE target_type,
1215 int target_number,
1216 omp_nest_lock_target_t *lock
1217 )
1218 {
1219 OFFLOAD ofld = OFFLOAD_TARGET_ACQUIRE(target_type, target_number, 0, NULL,
1220 __func__, 0);
1221 if (ofld != 0) {
1222 VarDesc vars[1] = {0};
1223
1224 vars[0].type.src = c_data;
1225 vars[0].type.dst = c_data;
1226 vars[0].direction.bits = c_parameter_inout;
1227 vars[0].size = sizeof(omp_nest_lock_target_t);
1228 vars[0].count = 1;
1229 vars[0].ptr = lock;
1230
1231 OFFLOAD_OFFLOAD(ofld, "omp_unset_nest_lock_target",
1232 0, 1, vars, NULL, 0, 0, 0);
1233 }
1234 }
1235
1236 int omp_test_nest_lock_target(
1237 TARGET_TYPE target_type,
1238 int target_number,
1239 omp_nest_lock_target_t *lock
1240 )
1241 {
1242 int result = 0;
1243
1244 OFFLOAD ofld = OFFLOAD_TARGET_ACQUIRE(target_type, target_number, 0, NULL,
1245 __func__, 0);
1246 if (ofld != 0) {
1247 VarDesc vars[2] = {0};
1248
1249 vars[0].type.src = c_data;
1250 vars[0].type.dst = c_data;
1251 vars[0].direction.bits = c_parameter_inout;
1252 vars[0].size = sizeof(omp_nest_lock_target_t);
1253 vars[0].count = 1;
1254 vars[0].ptr = lock;
1255
1256 vars[1].type.src = c_data;
1257 vars[1].type.dst = c_data;
1258 vars[1].direction.bits = c_parameter_out;
1259 vars[1].size = sizeof(int);
1260 vars[1].count = 1;
1261 vars[1].ptr = &result;
1262
1263 OFFLOAD_OFFLOAD(ofld, "omp_test_nest_lock_target",
1264 0, 2, vars, NULL, 0, 0, 0);
1265 }
1266 return result;
1267 }