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   return Manager->dataAlloc(DeviceId, Size, HstPtr);
89 }
90 
91 int32_t __tgt_rtl_data_submit(int32_t DeviceId, void *TgtPtr, void *HstPtr,
92                               int64_t Size) {
93   return Manager->dataSubmitAsync(DeviceId, TgtPtr, HstPtr, Size, nullptr);
94 }
95 
96 int32_t __tgt_rtl_data_submit_async(int32_t DeviceId, void *TgtPtr,
97                                     void *HstPtr, int64_t Size,
98                                     __tgt_async_info *AsyncInfo) {
99   return Manager->dataSubmitAsync(DeviceId, TgtPtr, HstPtr, Size, AsyncInfo);
100 }
101 
102 int32_t __tgt_rtl_data_retrieve(int32_t DeviceId, void *HstPtr, void *TgtPtr,
103                                 int64_t Size) {
104   return Manager->dataRetrieveAsync(DeviceId, HstPtr, TgtPtr, Size, nullptr);
105 }
106 
107 int32_t __tgt_rtl_data_retrieve_async(int32_t DeviceId, void *HstPtr,
108                                       void *TgtPtr, int64_t Size,
109                                       __tgt_async_info *AsyncInfo) {
110   return Manager->dataRetrieveAsync(DeviceId, HstPtr, TgtPtr, Size, AsyncInfo);
111 }
112 
113 int32_t __tgt_rtl_data_delete(int32_t DeviceId, void *TgtPtr) {
114   return Manager->dataDelete(DeviceId, TgtPtr);
115 }
116 
117 int32_t __tgt_rtl_data_exchange(int32_t SrcDevId, void *SrcPtr,
118                                 int32_t DstDevId, void *DstPtr, int64_t Size) {
119   return Manager->dataExchangeAsync(SrcDevId, SrcPtr, DstDevId, DstPtr, Size,
120                                     nullptr);
121 }
122 
123 int32_t __tgt_rtl_data_exchange_async(int32_t SrcDevId, void *SrcPtr,
124                                       int32_t DstDevId, void *DstPtr,
125                                       int64_t Size,
126                                       __tgt_async_info *AsyncInfo) {
127   return Manager->dataExchangeAsync(SrcDevId, SrcPtr, DstDevId, DstPtr, Size,
128                                     AsyncInfo);
129 }
130 
131 int32_t __tgt_rtl_run_target_region(int32_t DeviceId, void *TgtEntryPtr,
132                                     void **TgtArgs, ptrdiff_t *TgtOffsets,
133                                     int32_t ArgNum) {
134   return Manager->runTargetRegionAsync(DeviceId, TgtEntryPtr, TgtArgs,
135                                        TgtOffsets, ArgNum, nullptr);
136 }
137 
138 int32_t __tgt_rtl_run_target_region_async(int32_t DeviceId, void *TgtEntryPtr,
139                                           void **TgtArgs, ptrdiff_t *TgtOffsets,
140                                           int32_t ArgNum,
141                                           __tgt_async_info *AsyncInfo) {
142   return Manager->runTargetRegionAsync(DeviceId, TgtEntryPtr, TgtArgs,
143                                        TgtOffsets, ArgNum, AsyncInfo);
144 }
145 
146 int32_t __tgt_rtl_run_target_team_region(int32_t DeviceId, void *TgtEntryPtr,
147                                          void **TgtArgs, ptrdiff_t *TgtOffsets,
148                                          int32_t ArgNum, int32_t TeamNum,
149                                          int32_t ThreadLimit,
150                                          uint64_t LoopTripCount) {
151   return Manager->runTargetTeamRegionAsync(DeviceId, TgtEntryPtr, TgtArgs,
152                                            TgtOffsets, ArgNum, TeamNum,
153                                            ThreadLimit, LoopTripCount, nullptr);
154 }
155 
156 int32_t __tgt_rtl_run_target_team_region_async(
157     int32_t DeviceId, void *TgtEntryPtr, void **TgtArgs, ptrdiff_t *TgtOffsets,
158     int32_t ArgNum, int32_t TeamNum, int32_t ThreadLimit,
159     uint64_t LoopTripCount, __tgt_async_info *AsyncInfo) {
160   return Manager->runTargetTeamRegionAsync(
161       DeviceId, TgtEntryPtr, TgtArgs, TgtOffsets, ArgNum, TeamNum, ThreadLimit,
162       LoopTripCount, AsyncInfo);
163 }
164 
165 // Exposed library API function
166 #ifdef __cplusplus
167 }
168 #endif
169