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, __tgt_async_info *AsyncInfo) {
80   return Manager->synchronize(DeviceId, AsyncInfo);
81 }
82 
83 int32_t __tgt_rtl_is_data_exchangable(int32_t SrcDevId, int32_t DstDevId) {
84   return Manager->isDataExchangeable(SrcDevId, DstDevId);
85 }
86 
87 void *__tgt_rtl_data_alloc(int32_t DeviceId, int64_t Size, void *HstPtr,
88                            int32_t kind) {
89   if (kind != TARGET_ALLOC_DEFAULT) {
90     REPORT("Invalid target data allocation kind or requested allocator not "
91            "implemented yet\n");
92     return NULL;
93   }
94 
95   return Manager->dataAlloc(DeviceId, Size, HstPtr);
96 }
97 
98 int32_t __tgt_rtl_data_submit(int32_t DeviceId, void *TgtPtr, void *HstPtr,
99                               int64_t Size) {
100   return Manager->dataSubmitAsync(DeviceId, TgtPtr, HstPtr, Size, nullptr);
101 }
102 
103 int32_t __tgt_rtl_data_submit_async(int32_t DeviceId, void *TgtPtr,
104                                     void *HstPtr, int64_t Size,
105                                     __tgt_async_info *AsyncInfo) {
106   return Manager->dataSubmitAsync(DeviceId, TgtPtr, HstPtr, Size, AsyncInfo);
107 }
108 
109 int32_t __tgt_rtl_data_retrieve(int32_t DeviceId, void *HstPtr, void *TgtPtr,
110                                 int64_t Size) {
111   return Manager->dataRetrieveAsync(DeviceId, HstPtr, TgtPtr, Size, nullptr);
112 }
113 
114 int32_t __tgt_rtl_data_retrieve_async(int32_t DeviceId, void *HstPtr,
115                                       void *TgtPtr, int64_t Size,
116                                       __tgt_async_info *AsyncInfo) {
117   return Manager->dataRetrieveAsync(DeviceId, HstPtr, TgtPtr, Size, AsyncInfo);
118 }
119 
120 int32_t __tgt_rtl_data_delete(int32_t DeviceId, void *TgtPtr) {
121   return Manager->dataDelete(DeviceId, TgtPtr);
122 }
123 
124 int32_t __tgt_rtl_data_exchange(int32_t SrcDevId, void *SrcPtr,
125                                 int32_t DstDevId, void *DstPtr, int64_t Size) {
126   return Manager->dataExchangeAsync(SrcDevId, SrcPtr, DstDevId, DstPtr, Size,
127                                     nullptr);
128 }
129 
130 int32_t __tgt_rtl_data_exchange_async(int32_t SrcDevId, void *SrcPtr,
131                                       int32_t DstDevId, void *DstPtr,
132                                       int64_t Size,
133                                       __tgt_async_info *AsyncInfo) {
134   return Manager->dataExchangeAsync(SrcDevId, SrcPtr, DstDevId, DstPtr, Size,
135                                     AsyncInfo);
136 }
137 
138 int32_t __tgt_rtl_run_target_region(int32_t DeviceId, void *TgtEntryPtr,
139                                     void **TgtArgs, ptrdiff_t *TgtOffsets,
140                                     int32_t ArgNum) {
141   return Manager->runTargetRegionAsync(DeviceId, TgtEntryPtr, TgtArgs,
142                                        TgtOffsets, ArgNum, nullptr);
143 }
144 
145 int32_t __tgt_rtl_run_target_region_async(int32_t DeviceId, void *TgtEntryPtr,
146                                           void **TgtArgs, ptrdiff_t *TgtOffsets,
147                                           int32_t ArgNum,
148                                           __tgt_async_info *AsyncInfo) {
149   return Manager->runTargetRegionAsync(DeviceId, TgtEntryPtr, TgtArgs,
150                                        TgtOffsets, ArgNum, AsyncInfo);
151 }
152 
153 int32_t __tgt_rtl_run_target_team_region(int32_t DeviceId, void *TgtEntryPtr,
154                                          void **TgtArgs, ptrdiff_t *TgtOffsets,
155                                          int32_t ArgNum, int32_t TeamNum,
156                                          int32_t ThreadLimit,
157                                          uint64_t LoopTripCount) {
158   return Manager->runTargetTeamRegionAsync(DeviceId, TgtEntryPtr, TgtArgs,
159                                            TgtOffsets, ArgNum, TeamNum,
160                                            ThreadLimit, LoopTripCount, nullptr);
161 }
162 
163 int32_t __tgt_rtl_run_target_team_region_async(
164     int32_t DeviceId, void *TgtEntryPtr, void **TgtArgs, ptrdiff_t *TgtOffsets,
165     int32_t ArgNum, int32_t TeamNum, int32_t ThreadLimit,
166     uint64_t LoopTripCount, __tgt_async_info *AsyncInfo) {
167   return Manager->runTargetTeamRegionAsync(
168       DeviceId, TgtEntryPtr, TgtArgs, TgtOffsets, ArgNum, TeamNum, ThreadLimit,
169       LoopTripCount, AsyncInfo);
170 }
171 
172 // Exposed library API function
173 #ifdef __cplusplus
174 }
175 #endif
176