]> git.ipfire.org Git - thirdparty/gcc.git/blob - liboffloadmic/runtime/offload_common.cpp
72c355f6f1830488e6137a1bc216c1ef50a222c7
[thirdparty/gcc.git] / liboffloadmic / runtime / offload_common.cpp
1 /*
2 Copyright (c) 2014 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 #if defined(LINUX) || defined(FREEBSD)
32 #include <mm_malloc.h>
33 #endif
34
35 #include "offload_common.h"
36
37 // The debug routines
38
39 #if OFFLOAD_DEBUG > 0
40
41 void __dump_bytes(
42 int trace_level,
43 const void *data,
44 int len
45 )
46 {
47 if (console_enabled > trace_level) {
48 const uint8_t *arr = (const uint8_t*) data;
49 char buffer[4096];
50 char *bufferp;
51 int count = 0;
52
53 bufferp = buffer;
54 while (len--) {
55 sprintf(bufferp, "%02x", *arr++);
56 bufferp += 2;
57 count++;
58 if ((count&3) == 0) {
59 sprintf(bufferp, " ");
60 bufferp++;
61 }
62 if ((count&63) == 0) {
63 OFFLOAD_DEBUG_TRACE(trace_level, "%s\n", buffer);
64 bufferp = buffer;
65 count = 0;
66 }
67 }
68 if (count) {
69 OFFLOAD_DEBUG_TRACE(trace_level, "%s\n", buffer);
70 }
71 }
72 }
73 #endif // OFFLOAD_DEBUG
74
75 // The Marshaller and associated routines
76
77 void Marshaller::send_data(
78 const void *data,
79 int64_t length
80 )
81 {
82 OFFLOAD_DEBUG_TRACE(2, "send_data(%p, %lld)\n",
83 data, length);
84 memcpy(buffer_ptr, data, (size_t)length);
85 buffer_ptr += length;
86 tfr_size += length;
87 }
88
89 void Marshaller::receive_data(
90 void *data,
91 int64_t length
92 )
93 {
94 OFFLOAD_DEBUG_TRACE(2, "receive_data(%p, %lld)\n",
95 data, length);
96 memcpy(data, buffer_ptr, (size_t)length);
97 buffer_ptr += length;
98 tfr_size += length;
99 }
100
101 // Send function pointer
102 void Marshaller::send_func_ptr(
103 const void* data
104 )
105 {
106 const char* name;
107 size_t length;
108
109 if (data != 0) {
110 name = __offload_funcs.find_name(data);
111 if (name == 0) {
112 #if OFFLOAD_DEBUG > 0
113 if (console_enabled > 2) {
114 __offload_funcs.dump();
115 }
116 #endif // OFFLOAD_DEBUG > 0
117
118 LIBOFFLOAD_ERROR(c_send_func_ptr, data);
119 exit(1);
120 }
121 length = strlen(name) + 1;
122 }
123 else {
124 name = "";
125 length = 1;
126 }
127
128 memcpy(buffer_ptr, name, length);
129 buffer_ptr += length;
130 tfr_size += length;
131 }
132
133 // Receive function pointer
134 void Marshaller::receive_func_ptr(
135 const void** data
136 )
137 {
138 const char* name;
139 size_t length;
140
141 name = (const char*) buffer_ptr;
142 if (name[0] != '\0') {
143 *data = __offload_funcs.find_addr(name);
144 if (*data == 0) {
145 #if OFFLOAD_DEBUG > 0
146 if (console_enabled > 2) {
147 __offload_funcs.dump();
148 }
149 #endif // OFFLOAD_DEBUG > 0
150
151 LIBOFFLOAD_ERROR(c_receive_func_ptr, name);
152 exit(1);
153 }
154 length = strlen(name) + 1;
155 }
156 else {
157 *data = 0;
158 length = 1;
159 }
160
161 buffer_ptr += length;
162 tfr_size += length;
163 }
164
165 // End of the Marshaller and associated routines
166
167 extern void *OFFLOAD_MALLOC(
168 size_t size,
169 size_t align
170 )
171 {
172 void *ptr;
173 int err;
174
175 OFFLOAD_DEBUG_TRACE(2, "%s(%lld, %lld)\n", __func__, size, align);
176
177 if (align < sizeof(void*)) {
178 align = sizeof(void*);
179 }
180
181 ptr = _mm_malloc(size, align);
182 if (ptr == NULL) {
183 LIBOFFLOAD_ERROR(c_offload_malloc, size, align);
184 exit(1);
185 }
186
187 OFFLOAD_DEBUG_TRACE(2, "%s returned %p\n", __func__, ptr);
188
189 return ptr;
190 }