1 //===------------ rtl.h - Target independent OpenMP target RTL ------------===//
2 //
3 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
4 // See https://llvm.org/LICENSE.txt for license information.
5 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
6 //
7 //===----------------------------------------------------------------------===//
8 //
9 // Declarations for handling RTL plugins.
10 //
11 //===----------------------------------------------------------------------===//
12 
13 #ifndef _OMPTARGET_RTL_H
14 #define _OMPTARGET_RTL_H
15 
16 #include "omptarget.h"
17 #include <list>
18 #include <map>
19 #include <mutex>
20 #include <string>
21 #include <vector>
22 
23 // Forward declarations.
24 struct DeviceTy;
25 struct __tgt_bin_desc;
26 
27 struct RTLInfoTy {
28   typedef int32_t(is_valid_binary_ty)(void *);
29   typedef int32_t(is_data_exchangable_ty)(int32_t, int32_t);
30   typedef int32_t(number_of_devices_ty)();
31   typedef int32_t(init_device_ty)(int32_t);
32   typedef __tgt_target_table *(load_binary_ty)(int32_t, void *);
33   typedef void *(data_alloc_ty)(int32_t, int64_t, void *);
34   typedef int32_t(data_submit_ty)(int32_t, void *, void *, int64_t);
35   typedef int32_t(data_submit_async_ty)(int32_t, void *, void *, int64_t,
36                                         __tgt_async_info *);
37   typedef int32_t(data_retrieve_ty)(int32_t, void *, void *, int64_t);
38   typedef int32_t(data_retrieve_async_ty)(int32_t, void *, void *, int64_t,
39                                           __tgt_async_info *);
40   typedef int32_t(data_exchange_ty)(int32_t, void *, int32_t, void *, int64_t);
41   typedef int32_t(data_exchange_async_ty)(int32_t, void *, int32_t, void *,
42                                           int64_t, __tgt_async_info *);
43   typedef int32_t(data_delete_ty)(int32_t, void *);
44   typedef int32_t(run_region_ty)(int32_t, void *, void **, ptrdiff_t *,
45                                  int32_t);
46   typedef int32_t(run_region_async_ty)(int32_t, void *, void **, ptrdiff_t *,
47                                        int32_t, __tgt_async_info *);
48   typedef int32_t(run_team_region_ty)(int32_t, void *, void **, ptrdiff_t *,
49                                       int32_t, int32_t, int32_t, uint64_t);
50   typedef int32_t(run_team_region_async_ty)(int32_t, void *, void **,
51                                             ptrdiff_t *, int32_t, int32_t,
52                                             int32_t, uint64_t,
53                                             __tgt_async_info *);
54   typedef int64_t(init_requires_ty)(int64_t);
55   typedef int64_t(synchronize_ty)(int64_t, __tgt_async_info *);
56 
57   int32_t Idx = -1;             // RTL index, index is the number of devices
58                                 // of other RTLs that were registered before,
59                                 // i.e. the OpenMP index of the first device
60                                 // to be registered with this RTL.
61   int32_t NumberOfDevices = -1; // Number of devices this RTL deals with.
62 
63   void *LibraryHandler = nullptr;
64 
65 #ifdef OMPTARGET_DEBUG
66   std::string RTLName;
67 #endif
68 
69   // Functions implemented in the RTL.
70   is_valid_binary_ty *is_valid_binary = nullptr;
71   is_data_exchangable_ty *is_data_exchangable = nullptr;
72   number_of_devices_ty *number_of_devices = nullptr;
73   init_device_ty *init_device = nullptr;
74   load_binary_ty *load_binary = nullptr;
75   data_alloc_ty *data_alloc = nullptr;
76   data_submit_ty *data_submit = nullptr;
77   data_submit_async_ty *data_submit_async = nullptr;
78   data_retrieve_ty *data_retrieve = nullptr;
79   data_retrieve_async_ty *data_retrieve_async = nullptr;
80   data_exchange_ty *data_exchange = nullptr;
81   data_exchange_async_ty *data_exchange_async = nullptr;
82   data_delete_ty *data_delete = nullptr;
83   run_region_ty *run_region = nullptr;
84   run_region_async_ty *run_region_async = nullptr;
85   run_team_region_ty *run_team_region = nullptr;
86   run_team_region_async_ty *run_team_region_async = nullptr;
87   init_requires_ty *init_requires = nullptr;
88   synchronize_ty *synchronize = nullptr;
89 
90   // Are there images associated with this RTL.
91   bool isUsed = false;
92 
93   // Mutex for thread-safety when calling RTL interface functions.
94   // It is easier to enforce thread-safety at the libomptarget level,
95   // so that developers of new RTLs do not have to worry about it.
96   std::mutex Mtx;
97 
98   // The existence of the mutex above makes RTLInfoTy non-copyable.
99   // We need to provide a copy constructor explicitly.
100   RTLInfoTy() = default;
101 
RTLInfoTyRTLInfoTy102   RTLInfoTy(const RTLInfoTy &r) {
103     Idx = r.Idx;
104     NumberOfDevices = r.NumberOfDevices;
105     LibraryHandler = r.LibraryHandler;
106 #ifdef OMPTARGET_DEBUG
107     RTLName = r.RTLName;
108 #endif
109     is_valid_binary = r.is_valid_binary;
110     is_data_exchangable = r.is_data_exchangable;
111     number_of_devices = r.number_of_devices;
112     init_device = r.init_device;
113     load_binary = r.load_binary;
114     data_alloc = r.data_alloc;
115     data_submit = r.data_submit;
116     data_submit_async = r.data_submit_async;
117     data_retrieve = r.data_retrieve;
118     data_retrieve_async = r.data_retrieve_async;
119     data_exchange = r.data_exchange;
120     data_exchange_async = r.data_exchange_async;
121     data_delete = r.data_delete;
122     run_region = r.run_region;
123     run_region_async = r.run_region_async;
124     run_team_region = r.run_team_region;
125     run_team_region_async = r.run_team_region_async;
126     init_requires = r.init_requires;
127     isUsed = r.isUsed;
128     synchronize = r.synchronize;
129   }
130 };
131 
132 /// RTLs identified in the system.
133 class RTLsTy {
134 private:
135   // Mutex-like object to guarantee thread-safety and unique initialization
136   // (i.e. the library attempts to load the RTLs (plugins) only once).
137   std::once_flag initFlag;
138   void LoadRTLs(); // not thread-safe
139 
140 public:
141   // List of the detected runtime libraries.
142   std::list<RTLInfoTy> AllRTLs;
143 
144   // Array of pointers to the detected runtime libraries that have compatible
145   // binaries.
146   std::vector<RTLInfoTy *> UsedRTLs;
147 
148   int64_t RequiresFlags = OMP_REQ_UNDEFINED;
149 
150   explicit RTLsTy() = default;
151 
152   // Register the clauses of the requires directive.
153   void RegisterRequires(int64_t flags);
154 
155   // Register a shared library with all (compatible) RTLs.
156   void RegisterLib(__tgt_bin_desc *desc);
157 
158   // Unregister a shared library from all RTLs.
159   void UnregisterLib(__tgt_bin_desc *desc);
160 };
161 extern RTLsTy *RTLs;
162 extern std::mutex *RTLsMtx;
163 
164 
165 /// Map between the host entry begin and the translation table. Each
166 /// registered library gets one TranslationTable. Use the map from
167 /// __tgt_offload_entry so that we may quickly determine whether we
168 /// are trying to (re)register an existing lib or really have a new one.
169 struct TranslationTable {
170   __tgt_target_table HostTable;
171 
172   // Image assigned to a given device.
173   std::vector<__tgt_device_image *> TargetsImages; // One image per device ID.
174 
175   // Table of entry points or NULL if it was not already computed.
176   std::vector<__tgt_target_table *> TargetsTable; // One table per device ID.
177 };
178 typedef std::map<__tgt_offload_entry *, TranslationTable>
179     HostEntriesBeginToTransTableTy;
180 extern HostEntriesBeginToTransTableTy *HostEntriesBeginToTransTable;
181 extern std::mutex *TrlTblMtx;
182 
183 /// Map between the host ptr and a table index
184 struct TableMap {
185   TranslationTable *Table = nullptr; // table associated with the host ptr.
186   uint32_t Index = 0; // index in which the host ptr translated entry is found.
187   TableMap() = default;
TableMapTableMap188   TableMap(TranslationTable *table, uint32_t index)
189       : Table(table), Index(index) {}
190 };
191 typedef std::map<void *, TableMap> HostPtrToTableMapTy;
192 extern HostPtrToTableMapTy *HostPtrToTableMap;
193 extern std::mutex *TblMapMtx;
194 
195 #endif
196