|
111
|
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 /*! \file
|
|
|
32 \brief Function and Variable tables used by the runtime library
|
|
|
33 */
|
|
|
34
|
|
|
35 #ifndef OFFLOAD_TABLE_H_INCLUDED
|
|
|
36 #define OFFLOAD_TABLE_H_INCLUDED
|
|
|
37
|
|
|
38 #include "offload_util.h"
|
|
|
39
|
|
|
40 #define OFFLOAD_VERSION_16 1600
|
|
|
41 #define OFFLOAD_VERSION_17 1700
|
|
|
42
|
|
|
43 // Template representing double linked list of tables
|
|
|
44 template <typename T> class TableList {
|
|
|
45 public:
|
|
|
46 // table type
|
|
|
47 typedef T Table;
|
|
|
48
|
|
|
49 // List node
|
|
|
50 struct Node {
|
|
|
51 Table table;
|
|
|
52 Node* prev;
|
|
|
53 Node* next;
|
|
|
54 };
|
|
|
55
|
|
|
56 public:
|
|
|
57 explicit TableList(Node *node = 0) : m_head(node) {}
|
|
|
58
|
|
|
59 void add_table(Node *node) {
|
|
|
60 m_lock.lock();
|
|
|
61 if (m_head != 0) {
|
|
|
62 node->next = m_head;
|
|
|
63 m_head->prev = node;
|
|
|
64 }
|
|
|
65 m_head = node;
|
|
|
66
|
|
|
67 m_lock.unlock();
|
|
|
68 }
|
|
|
69
|
|
|
70 void remove_table(Node *node) {
|
|
|
71 if (node->next != 0) {
|
|
|
72 node->next->prev = node->prev;
|
|
|
73 }
|
|
|
74 if (node->prev != 0) {
|
|
|
75 node->prev->next = node->next;
|
|
|
76 }
|
|
|
77 if (m_head == node) {
|
|
|
78 m_head = node->next;
|
|
|
79 }
|
|
|
80 }
|
|
|
81
|
|
|
82 protected:
|
|
|
83 Node* m_head;
|
|
|
84 mutex_t m_lock;
|
|
|
85 };
|
|
|
86
|
|
|
87 // Function lookup table.
|
|
|
88 struct FuncTable {
|
|
|
89 //! Function table entry
|
|
|
90 /*! This table contains functions created from offload regions. */
|
|
|
91 /*! Each entry consists of a pointer to the function's "key"
|
|
|
92 and the function address. */
|
|
|
93 /*! Each shared library or executable may contain one such table. */
|
|
|
94 /*! The end of the table is marked with an entry whose name field
|
|
|
95 has value -1. */
|
|
|
96 struct Entry {
|
|
|
97 const char* name; //!< Name of the function
|
|
|
98 void* func; //!< Address of the function
|
|
|
99 };
|
|
|
100
|
|
|
101 // entries
|
|
|
102 const Entry *entries;
|
|
|
103
|
|
|
104 // max name length
|
|
|
105 int64_t max_name_len;
|
|
|
106 };
|
|
|
107
|
|
|
108 // Function table
|
|
|
109 class DLL_LOCAL FuncList : public TableList<FuncTable> {
|
|
|
110 public:
|
|
|
111 explicit FuncList(Node *node = 0) : TableList<Table>(node),
|
|
|
112 m_max_name_len(-1)
|
|
|
113 {}
|
|
|
114
|
|
|
115 // add table to the list
|
|
|
116 void add_table(Node *node) {
|
|
|
117 // recalculate max function name length
|
|
|
118 m_max_name_len = -1;
|
|
|
119
|
|
|
120 // add table
|
|
|
121 TableList<Table>::add_table(node);
|
|
|
122 }
|
|
|
123
|
|
|
124 // find function address for the given name
|
|
|
125 const void* find_addr(const char *name);
|
|
|
126
|
|
|
127 // find function name for the given address
|
|
|
128 const char* find_name(const void *addr);
|
|
|
129
|
|
|
130 // max name length from all tables in the list
|
|
|
131 int64_t max_name_length(void);
|
|
|
132
|
|
|
133 // debug dump
|
|
|
134 void dump(void);
|
|
|
135
|
|
|
136 private:
|
|
|
137 // max name length within from all tables
|
|
|
138 int64_t m_max_name_len;
|
|
|
139 };
|
|
|
140
|
|
|
141 #define VAR_ALLOC_TYPE uint64_t
|
|
|
142 #define OPENMP_IMPLICIT 1 // Compiler promoted openmp declare var
|
|
|
143 // due to implicit use without openmp declare
|
|
|
144 #define OPENMP_LINK 2 // Openmp link clause in openmp declare
|
|
|
145
|
|
|
146 #define IS_OPENMP_IMPLICIT(var_alloc_type) (var_alloc_type & 1)
|
|
|
147 #define IS_OPENMP_LINK(var_alloc_type) (var_alloc_type & 2)
|
|
|
148 #define IS_OPENMP_IMPLICIT_OR_LINK(var_alloc_type) (var_alloc_type & 3)
|
|
|
149
|
|
|
150 // Table entry for static variables
|
|
|
151 struct VarTable {
|
|
|
152 //! Variable table entry
|
|
|
153 /*! This table contains statically allocated variables marked with
|
|
|
154 __declspec(target(mic) or #pragma omp declare target. */
|
|
|
155 /*! Each entry consists of a pointer to the variable's "key",
|
|
|
156 the variable address and its size in bytes. */
|
|
|
157 /*! Because memory allocation is done from the host,
|
|
|
158 the MIC table does not need the size of the variable. */
|
|
|
159 /*! Padding to make the table entry size a power of 2 is necessary
|
|
|
160 to avoid "holes" between table contributions from different object
|
|
|
161 files on Windows when debug information is specified with /Zi. */
|
|
|
162 struct Entry {
|
|
|
163 const char* name; //!< Name of the variable
|
|
|
164 void* addr; //!< Address of the variable
|
|
|
165
|
|
|
166 #if HOST_LIBRARY
|
|
|
167 VAR_ALLOC_TYPE var_alloc_type;
|
|
|
168 uint64_t size;
|
|
|
169 #endif
|
|
|
170 };
|
|
|
171
|
|
|
172 // Table terminated by an entry with name == -1
|
|
|
173 const Entry *entries;
|
|
|
174 };
|
|
|
175
|
|
|
176 // List of var tables
|
|
|
177 class DLL_LOCAL VarList : public TableList<VarTable> {
|
|
|
178 public:
|
|
|
179 VarList() : TableList<Table>()
|
|
|
180 {}
|
|
|
181
|
|
|
182 // debug dump
|
|
|
183 void dump();
|
|
|
184
|
|
|
185 public:
|
|
|
186
|
|
|
187 Node * get_head() {
|
|
|
188 return m_head;
|
|
|
189 }
|
|
|
190
|
|
|
191 public:
|
|
|
192 // Entry representation in a copy buffer
|
|
|
193 struct BufEntry {
|
|
|
194 intptr_t name;
|
|
|
195 intptr_t addr;
|
|
|
196 };
|
|
|
197
|
|
|
198 // Calculate the number of elements in the table and
|
|
|
199 // returns the size of buffer for the table
|
|
|
200 int64_t table_size(int64_t &nelems);
|
|
|
201
|
|
|
202 // Copy table contents to given buffer. It is supposed to be large
|
|
|
203 // enough to hold all elements as string table.
|
|
|
204 void table_copy(void *buf, int64_t nelems);
|
|
|
205
|
|
|
206 // Patch name offsets in a table after it's been copied to other side
|
|
|
207 static void table_patch_names(void *buf, int64_t nelems);
|
|
|
208 };
|
|
|
209
|
|
|
210 DLL_LOCAL extern FuncList __offload_entries;
|
|
|
211 DLL_LOCAL extern FuncList __offload_funcs;
|
|
|
212 DLL_LOCAL extern VarList __offload_vars;
|
|
|
213
|
|
|
214 // Section names where the lookup tables are stored
|
|
|
215 #ifdef TARGET_WINNT
|
|
|
216 #define OFFLOAD_ENTRY_TABLE_SECTION_START ".OffloadEntryTable$a"
|
|
|
217 #define OFFLOAD_ENTRY_TABLE_SECTION_END ".OffloadEntryTable$z"
|
|
|
218
|
|
|
219 #define OFFLOAD_FUNC_TABLE_SECTION_START ".OffloadFuncTable$a"
|
|
|
220 #define OFFLOAD_FUNC_TABLE_SECTION_END ".OffloadFuncTable$z"
|
|
|
221
|
|
|
222 #define OFFLOAD_VAR_TABLE_SECTION_START ".OffloadVarTable$a"
|
|
|
223 #define OFFLOAD_VAR_TABLE_SECTION_END ".OffloadVarTable$z"
|
|
|
224
|
|
|
225 #define OFFLOAD_CRTINIT_SECTION_START ".CRT$XCT"
|
|
|
226
|
|
|
227 #pragma section(OFFLOAD_CRTINIT_SECTION_START, read)
|
|
|
228
|
|
|
229 #else // TARGET_WINNT
|
|
|
230
|
|
|
231 #define OFFLOAD_ENTRY_TABLE_SECTION_START ".OffloadEntryTable."
|
|
|
232 #define OFFLOAD_ENTRY_TABLE_SECTION_END ".OffloadEntryTable."
|
|
|
233
|
|
|
234 #define OFFLOAD_FUNC_TABLE_SECTION_START ".OffloadFuncTable."
|
|
|
235 #define OFFLOAD_FUNC_TABLE_SECTION_END ".OffloadFuncTable."
|
|
|
236
|
|
|
237 #define OFFLOAD_VAR_TABLE_SECTION_START ".OffloadVarTable."
|
|
|
238 #define OFFLOAD_VAR_TABLE_SECTION_END ".OffloadVarTable."
|
|
|
239 #endif // TARGET_WINNT
|
|
|
240
|
|
|
241 #pragma section(OFFLOAD_ENTRY_TABLE_SECTION_START, read, write)
|
|
|
242 #pragma section(OFFLOAD_ENTRY_TABLE_SECTION_END, read, write)
|
|
|
243
|
|
|
244 #pragma section(OFFLOAD_FUNC_TABLE_SECTION_START, read, write)
|
|
|
245 #pragma section(OFFLOAD_FUNC_TABLE_SECTION_END, read, write)
|
|
|
246
|
|
|
247 #pragma section(OFFLOAD_VAR_TABLE_SECTION_START, read, write)
|
|
|
248 #pragma section(OFFLOAD_VAR_TABLE_SECTION_END, read, write)
|
|
|
249
|
|
|
250
|
|
|
251 // Set library version
|
|
|
252 extern "C" void __offload_set_version(int v);
|
|
|
253
|
|
|
254 // register/unregister given tables
|
|
|
255 extern "C" void __offload_register_tables(
|
|
|
256 FuncList::Node *entry_table,
|
|
|
257 FuncList::Node *func_table,
|
|
|
258 VarList::Node *var_table
|
|
|
259 );
|
|
|
260
|
|
|
261 extern "C" void __offload_unregister_tables(
|
|
|
262 FuncList::Node *entry_table,
|
|
|
263 FuncList::Node *func_table,
|
|
|
264 VarList::Node *var_table
|
|
|
265 );
|
|
|
266
|
|
|
267
|
|
|
268 #ifdef MYO_SUPPORT
|
|
|
269
|
|
|
270 #include <myotypes.h>
|
|
|
271 #include <myoimpl.h>
|
|
|
272 #include <myo.h>
|
|
|
273
|
|
|
274 #ifdef TARGET_WINNT
|
|
|
275 #define MYO_TABLE_END_MARKER() reinterpret_cast<const char*>(-1)
|
|
|
276 #else // TARGET_WINNT
|
|
|
277 #define MYO_TABLE_END_MARKER() reinterpret_cast<const char*>(0)
|
|
|
278 #endif // TARGET_WINNT
|
|
|
279
|
|
|
280 // Host and Target-side MYO shared variable table entry layout
|
|
|
281 typedef MyoiSharedVarEntry SharedTableEntry;
|
|
|
282
|
|
|
283 #if HOST_LIBRARY
|
|
|
284
|
|
|
285 // Host-side MYO function table entry layout
|
|
|
286 typedef struct {
|
|
|
287 //! Function Name
|
|
|
288 const char *funcName;
|
|
|
289 //! Function Address
|
|
|
290 void *funcAddr;
|
|
|
291 //! Local Thunk Address
|
|
|
292 void *localThunkAddr;
|
|
|
293 #ifdef TARGET_WINNT
|
|
|
294 // Dummy to pad up to 32 bytes
|
|
|
295 void *dummy;
|
|
|
296 #endif // TARGET_WINNT
|
|
|
297 } FptrTableEntry;
|
|
|
298
|
|
|
299 // Host-side MYO init routine table entry layout
|
|
|
300 typedef struct {
|
|
|
301 #ifdef TARGET_WINNT
|
|
|
302 // Dummy to pad up to 16 bytes
|
|
|
303 // Function Name
|
|
|
304 const char *funcName;
|
|
|
305 #endif // TARGET_WINNT
|
|
|
306 void (*func)(MyoArena);
|
|
|
307 } InitTableEntry;
|
|
|
308
|
|
|
309 #else // HOST_LIBRARY
|
|
|
310
|
|
|
311 // Target-side MYO function table entry layout
|
|
|
312 typedef MyoiTargetSharedFptrEntry FptrTableEntry;
|
|
|
313
|
|
|
314 // Target-side MYO init routine table entry layout
|
|
|
315 struct InitTableEntry {
|
|
|
316 void (*func)(void);
|
|
|
317 };
|
|
|
318
|
|
|
319 #endif // HOST_LIBRARY
|
|
|
320
|
|
|
321 #ifdef TARGET_WINNT
|
|
|
322
|
|
|
323 #define OFFLOAD_MYO_SHARED_TABLE_SECTION_START ".MyoSharedTable$a"
|
|
|
324 #define OFFLOAD_MYO_SHARED_TABLE_SECTION_END ".MyoSharedTable$z"
|
|
|
325
|
|
|
326 #define OFFLOAD_MYO_SHARED_VTABLE_SECTION_START ".MyoSharedVTable$a"
|
|
|
327 #define OFFLOAD_MYO_SHARED_VTABLE_SECTION_END ".MyoSharedVTable$z"
|
|
|
328
|
|
|
329 #define OFFLOAD_MYO_SHARED_INIT_TABLE_SECTION_START ".MyoSharedInitTable$a"
|
|
|
330 #define OFFLOAD_MYO_SHARED_INIT_TABLE_SECTION_END ".MyoSharedInitTable$z"
|
|
|
331
|
|
|
332 #define OFFLOAD_MYO_FPTR_TABLE_SECTION_START ".MyoFptrTable$a"
|
|
|
333 #define OFFLOAD_MYO_FPTR_TABLE_SECTION_END ".MyoFptrTable$z"
|
|
|
334
|
|
|
335 #else // TARGET_WINNT
|
|
|
336
|
|
|
337 #define OFFLOAD_MYO_SHARED_TABLE_SECTION_START ".MyoSharedTable."
|
|
|
338 #define OFFLOAD_MYO_SHARED_TABLE_SECTION_END ".MyoSharedTable."
|
|
|
339
|
|
|
340 #define OFFLOAD_MYO_SHARED_VTABLE_SECTION_START ".MyoSharedVTable."
|
|
|
341 #define OFFLOAD_MYO_SHARED_VTABLE_SECTION_END ".MyoSharedVTable."
|
|
|
342
|
|
|
343 #define OFFLOAD_MYO_SHARED_INIT_TABLE_SECTION_START ".MyoSharedInitTable."
|
|
|
344 #define OFFLOAD_MYO_SHARED_INIT_TABLE_SECTION_END ".MyoSharedInitTable."
|
|
|
345
|
|
|
346 #define OFFLOAD_MYO_FPTR_TABLE_SECTION_START ".MyoFptrTable."
|
|
|
347 #define OFFLOAD_MYO_FPTR_TABLE_SECTION_END ".MyoFptrTable."
|
|
|
348
|
|
|
349 #endif // TARGET_WINNT
|
|
|
350
|
|
|
351 #pragma section(OFFLOAD_MYO_SHARED_TABLE_SECTION_START, read, write)
|
|
|
352 #pragma section(OFFLOAD_MYO_SHARED_TABLE_SECTION_END, read, write)
|
|
|
353
|
|
|
354 #pragma section(OFFLOAD_MYO_SHARED_VTABLE_SECTION_START, read, write)
|
|
|
355 #pragma section(OFFLOAD_MYO_SHARED_VTABLE_SECTION_END, read, write)
|
|
|
356
|
|
|
357 #pragma section(OFFLOAD_MYO_SHARED_INIT_TABLE_SECTION_START, read, write)
|
|
|
358 #pragma section(OFFLOAD_MYO_SHARED_INIT_TABLE_SECTION_END, read, write)
|
|
|
359
|
|
|
360 #pragma section(OFFLOAD_MYO_FPTR_TABLE_SECTION_START, read, write)
|
|
|
361 #pragma section(OFFLOAD_MYO_FPTR_TABLE_SECTION_END, read, write)
|
|
|
362
|
|
|
363 // List of MYO shared variable tables
|
|
|
364 struct MYOVarTable {
|
|
|
365 typedef SharedTableEntry Entry;
|
|
|
366 const Entry *entries;
|
|
|
367 };
|
|
|
368
|
|
|
369 class MYOVarTableList : public TableList<MYOVarTable> {
|
|
|
370 public:
|
|
|
371 MYOVarTableList() : TableList<Table>()
|
|
|
372 {}
|
|
|
373
|
|
|
374 // add table to the list
|
|
|
375 void add_table(Node *node) {
|
|
|
376 // add table
|
|
|
377 TableList<Table>::add_table(node);
|
|
|
378 }
|
|
|
379
|
|
|
380 // debug dump
|
|
|
381 void dump(void);
|
|
|
382
|
|
|
383 // check if any shared variables
|
|
|
384 bool is_empty();
|
|
|
385
|
|
|
386 // process the table contents for ordinary variables
|
|
|
387 void process();
|
|
|
388
|
|
|
389 // process the table contents for vtable objects
|
|
|
390 void process_vtable();
|
|
|
391 };
|
|
|
392
|
|
|
393 // List of MYO shared function tables
|
|
|
394 struct MYOFuncTable {
|
|
|
395 typedef FptrTableEntry Entry;
|
|
|
396 const Entry *entries;
|
|
|
397 };
|
|
|
398
|
|
|
399 class MYOFuncTableList : public TableList<MYOFuncTable> {
|
|
|
400 public:
|
|
|
401 MYOFuncTableList() : TableList<Table>()
|
|
|
402 {}
|
|
|
403
|
|
|
404 // add table to the list
|
|
|
405 void add_table(Node *node) {
|
|
|
406 // add table
|
|
|
407 TableList<Table>::add_table(node);
|
|
|
408 }
|
|
|
409
|
|
|
410 // debug dump
|
|
|
411 void dump(void);
|
|
|
412
|
|
|
413 // check if any shared functions
|
|
|
414 bool is_empty();
|
|
|
415
|
|
|
416 // process the table contents
|
|
|
417 void process();
|
|
|
418 };
|
|
|
419
|
|
|
420 // List of MYO shared variable initialization routine tables
|
|
|
421 struct MYOInitTable {
|
|
|
422 typedef InitTableEntry Entry;
|
|
|
423 const Entry *entries;
|
|
|
424 };
|
|
|
425
|
|
|
426 class MYOInitTableList : public TableList<MYOInitTable> {
|
|
|
427 public:
|
|
|
428 MYOInitTableList() : TableList<Table>()
|
|
|
429 {}
|
|
|
430
|
|
|
431 // add table to the list
|
|
|
432 void add_table(Node *node) {
|
|
|
433 // add table
|
|
|
434 TableList<Table>::add_table(node);
|
|
|
435 }
|
|
|
436
|
|
|
437 // debug dump
|
|
|
438 void dump(void);
|
|
|
439
|
|
|
440 // check if any init routines
|
|
|
441 bool is_empty();
|
|
|
442
|
|
|
443 // process the table contents
|
|
|
444 void process();
|
|
|
445 };
|
|
|
446
|
|
|
447 extern MYOVarTableList __offload_myo_var_tables;
|
|
|
448 extern MYOVarTableList __offload_myo_vtable_tables;
|
|
|
449 extern MYOFuncTableList __offload_myo_func_tables;
|
|
|
450 extern MYOInitTableList __offload_myo_init_tables;
|
|
|
451
|
|
|
452 extern "C" void __offload_myoRegisterTables1(
|
|
|
453 MYOInitTableList::Node *init_table,
|
|
|
454 MYOVarTableList::Node *shared_table,
|
|
|
455 MYOVarTableList::Node *shared_vtable,
|
|
|
456 MYOFuncTableList::Node *fptr_table
|
|
|
457 );
|
|
|
458
|
|
|
459 extern "C" void __offload_myoRemoveTables(
|
|
|
460 MYOInitTableList::Node *init_table,
|
|
|
461 MYOVarTableList::Node *shared_table,
|
|
|
462 MYOVarTableList::Node *shared_vtable,
|
|
|
463 MYOFuncTableList::Node *fptr_table
|
|
|
464 );
|
|
|
465
|
|
|
466 #endif // MYO_SUPPORT
|
|
|
467
|
|
|
468 #endif // OFFLOAD_TABLE_H_INCLUDED
|
