1 //===--------------------- rtl.cpp - Remote RTL Plugin --------------------===//
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 // RTL for Host.
10 //
11 //===----------------------------------------------------------------------===//
12 
13 #include <cstddef>
14 #include <memory>
15 #include <string>
16 
17 #include "Client.h"
18 #include "Utils.h"
19 #include "omptarget.h"
20 #include "omptargetplugin.h"
21 
22 #define TARGET_NAME RPC
23 #define DEBUG_PREFIX "Target " GETNAME(TARGET_NAME) " RTL"
24 
25 RemoteClientManager *Manager;
26 
27 __attribute__((constructor(101))) void initRPC() {
28   DP("Init RPC library!\n");
29 
30   RPCConfig Config;
31   parseEnvironment(Config);
32 
33   int Timeout = 5;
34   if (const char *Env1 = std::getenv("LIBOMPTARGET_RPC_LATENCY"))
35     Timeout = std::stoi(Env1);
36 
37   Manager = new RemoteClientManager(Config.ServerAddresses, Timeout,
38                                     Config.MaxSize, Config.BlockSize);
39 }
40 
41 __attribute__((destructor(101))) void deinitRPC() {
42   Manager->shutdown(); // TODO: Error handle shutting down
43   DP("Deinit RPC library!\n");
44   delete Manager;
45 }
46 
47 // Exposed library API function
48 #ifdef __cplusplus
49 extern "C" {
50 #endif
51 
52 int32_t __tgt_rtl_register_lib(__tgt_bin_desc *Desc) {
53   return Manager->registerLib(Desc);
54 }
55 
56 int32_t __tgt_rtl_unregister_lib(__tgt_bin_desc *Desc) {
57   return Manager->unregisterLib(Desc);
58 }
59 
60 int32_t __tgt_rtl_is_valid_binary(__tgt_device_image *Image) {
61   return Manager->isValidBinary(Image);
62 }
63 
64 int32_t __tgt_rtl_number_of_devices() { return Manager->getNumberOfDevices(); }
65 
66 int32_t __tgt_rtl_init_device(int32_t DeviceId) {
67   return Manager->initDevice(DeviceId);
68 }
69 
70 int64_t __tgt_rtl_init_requires(int64_t RequiresFlags) {
71   return Manager->initRequires(RequiresFlags);
72 }
73 
74 __tgt_target_table *__tgt_rtl_load_binary(int32_t DeviceId,
75                                           __tgt_device_image *Image) {
76   return Manager->loadBinary(DeviceId, (__tgt_device_image *)Image);
77 }
78 
79 int32_t __tgt_rtl_synchronize(int32_t DeviceId,
80                               __tgt_async_info *AsyncInfoPtr) {
81   return Manager->synchronize(DeviceId, AsyncInfoPtr);
82 }
83 
84 int32_t __tgt_rtl_is_data_exchangable(int32_t SrcDevId, int32_t DstDevId) {
85   return Manager->isDataExchangeable(SrcDevId, DstDevId);
86 }
87 
88 void *__tgt_rtl_data_alloc(int32_t DeviceId, int64_t Size, void *HstPtr) {
89   return Manager->dataAlloc(DeviceId, Size, HstPtr);
90 }
91 
92 int32_t __tgt_rtl_data_submit(int32_t DeviceId, void *TgtPtr, void *HstPtr,
93                               int64_t Size) {
94   return Manager->dataSubmitAsync(DeviceId, TgtPtr, HstPtr, Size, nullptr);
95 }
96 
97 int32_t __tgt_rtl_data_submit_async(int32_t DeviceId, void *TgtPtr,
98                                     void *HstPtr, int64_t Size,
99                                     __tgt_async_info *AsyncInfoPtr) {
100   return Manager->dataSubmitAsync(DeviceId, TgtPtr, HstPtr, Size, AsyncInfoPtr);
101 }
102 
103 int32_t __tgt_rtl_data_retrieve(int32_t DeviceId, void *HstPtr, void *TgtPtr,
104                                 int64_t Size) {
105   return Manager->dataRetrieveAsync(DeviceId, HstPtr, TgtPtr, Size, nullptr);
106 }
107 
108 int32_t __tgt_rtl_data_retrieve_async(int32_t DeviceId, void *HstPtr,
109                                       void *TgtPtr, int64_t Size,
110                                       __tgt_async_info *AsyncInfoPtr) {
111   return Manager->dataRetrieveAsync(DeviceId, HstPtr, TgtPtr, Size,
112                                     AsyncInfoPtr);
113 }
114 
115 int32_t __tgt_rtl_data_delete(int32_t DeviceId, void *TgtPtr) {
116   return Manager->dataDelete(DeviceId, TgtPtr);
117 }
118 
119 int32_t __tgt_rtl_data_exchange(int32_t SrcDevId, void *SrcPtr,
120                                 int32_t DstDevId, void *DstPtr, int64_t Size) {
121   return Manager->dataExchangeAsync(SrcDevId, SrcPtr, DstDevId, DstPtr, Size,
122                                     nullptr);
123 }
124 
125 int32_t __tgt_rtl_data_exchange_async(int32_t SrcDevId, void *SrcPtr,
126                                       int32_t DstDevId, void *DstPtr,
127                                       int64_t Size,
128                                       __tgt_async_info *AsyncInfoPtr) {
129   return Manager->dataExchangeAsync(SrcDevId, SrcPtr, DstDevId, DstPtr, Size,
130                                     AsyncInfoPtr);
131 }
132 
133 int32_t __tgt_rtl_run_target_region(int32_t DeviceId, void *TgtEntryPtr,
134                                     void **TgtArgs, ptrdiff_t *TgtOffsets,
135                                     int32_t ArgNum) {
136   return Manager->runTargetRegionAsync(DeviceId, TgtEntryPtr, TgtArgs,
137                                        TgtOffsets, ArgNum, nullptr);
138 }
139 
140 int32_t __tgt_rtl_run_target_region_async(int32_t DeviceId, void *TgtEntryPtr,
141                                           void **TgtArgs, ptrdiff_t *TgtOffsets,
142                                           int32_t ArgNum,
143                                           __tgt_async_info *AsyncInfoPtr) {
144   return Manager->runTargetRegionAsync(DeviceId, TgtEntryPtr, TgtArgs,
145                                        TgtOffsets, ArgNum, AsyncInfoPtr);
146 }
147 
148 int32_t __tgt_rtl_run_target_team_region(int32_t DeviceId, void *TgtEntryPtr,
149                                          void **TgtArgs, ptrdiff_t *TgtOffsets,
150                                          int32_t ArgNum, int32_t TeamNum,
151                                          int32_t ThreadLimit,
152                                          uint64_t LoopTripCount) {
153   return Manager->runTargetTeamRegionAsync(DeviceId, TgtEntryPtr, TgtArgs,
154                                            TgtOffsets, ArgNum, TeamNum,
155                                            ThreadLimit, LoopTripCount, nullptr);
156 }
157 
158 int32_t __tgt_rtl_run_target_team_region_async(
159     int32_t DeviceId, void *TgtEntryPtr, void **TgtArgs, ptrdiff_t *TgtOffsets,
160     int32_t ArgNum, int32_t TeamNum, int32_t ThreadLimit,
161     uint64_t LoopTripCount, __tgt_async_info *AsyncInfoPtr) {
162   return Manager->runTargetTeamRegionAsync(
163       DeviceId, TgtEntryPtr, TgtArgs, TgtOffsets, ArgNum, TeamNum, ThreadLimit,
164       LoopTripCount, AsyncInfoPtr);
165 }
166 
167 // Exposed library API function
168 #ifdef __cplusplus
169 }
170 #endif
171