1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
|
//===--------------------- rtl.cpp - Remote RTL Plugin --------------------===//
//
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
//
//===----------------------------------------------------------------------===//
//
// RTL for Host.
//
//===----------------------------------------------------------------------===//
#include <cstddef>
#include <memory>
#include <string>
#include "Client.h"
#include "Utils.h"
#include "omptarget.h"
#include "omptargetplugin.h"
#define TARGET_NAME RPC
#define DEBUG_PREFIX "Target " GETNAME(TARGET_NAME) " RTL"
RemoteClientManager *Manager;
__attribute__((constructor(101))) void initRPC() {
DP("Init RPC library!\n");
Manager = new RemoteClientManager();
}
__attribute__((destructor(101))) void deinitRPC() {
Manager->shutdown(); // TODO: Error handle shutting down
DP("Deinit RPC library!\n");
delete Manager;
}
// Exposed library API function
#ifdef __cplusplus
extern "C" {
#endif
int32_t __tgt_rtl_register_lib(__tgt_bin_desc *Desc) {
return Manager->registerLib(Desc);
}
int32_t __tgt_rtl_unregister_lib(__tgt_bin_desc *Desc) {
return Manager->unregisterLib(Desc);
}
int32_t __tgt_rtl_is_valid_binary(__tgt_device_image *Image) {
return Manager->isValidBinary(Image);
}
int32_t __tgt_rtl_number_of_devices() { return Manager->getNumberOfDevices(); }
int32_t __tgt_rtl_init_device(int32_t DeviceId) {
return Manager->initDevice(DeviceId);
}
int64_t __tgt_rtl_init_requires(int64_t RequiresFlags) {
return Manager->initRequires(RequiresFlags);
}
__tgt_target_table *__tgt_rtl_load_binary(int32_t DeviceId,
__tgt_device_image *Image) {
return Manager->loadBinary(DeviceId, (__tgt_device_image *)Image);
}
int32_t __tgt_rtl_is_data_exchangable(int32_t SrcDevId, int32_t DstDevId) {
return Manager->isDataExchangeable(SrcDevId, DstDevId);
}
void *__tgt_rtl_data_alloc(int32_t DeviceId, int64_t Size, void *HstPtr,
int32_t Kind) {
if (Kind != TARGET_ALLOC_DEFAULT) {
REPORT("Invalid target data allocation kind or requested allocator not "
"implemented yet\n");
return NULL;
}
return Manager->dataAlloc(DeviceId, Size, HstPtr);
}
int32_t __tgt_rtl_data_submit(int32_t DeviceId, void *TgtPtr, void *HstPtr,
int64_t Size) {
return Manager->dataSubmit(DeviceId, TgtPtr, HstPtr, Size);
}
int32_t __tgt_rtl_data_retrieve(int32_t DeviceId, void *HstPtr, void *TgtPtr,
int64_t Size) {
return Manager->dataRetrieve(DeviceId, HstPtr, TgtPtr, Size);
}
int32_t __tgt_rtl_data_delete(int32_t DeviceId, void *TgtPtr, int32_t) {
return Manager->dataDelete(DeviceId, TgtPtr);
}
int32_t __tgt_rtl_data_exchange(int32_t SrcDevId, void *SrcPtr,
int32_t DstDevId, void *DstPtr, int64_t Size) {
return Manager->dataExchange(SrcDevId, SrcPtr, DstDevId, DstPtr, Size);
}
int32_t __tgt_rtl_launch_kernel(int32_t DeviceId, void *TgtEntryPtr,
void **TgtArgs, ptrdiff_t *TgtOffsets,
KernelArgsTy *KernelArgs,
__tgt_async_info *AsyncInfoPtr) {
assert(!KernelArgs->NumTeams[1] && !KernelArgs->NumTeams[2] &&
!KernelArgs->ThreadLimit[1] && !KernelArgs->ThreadLimit[2] &&
"Only one dimensional kernels supported.");
return Manager->runTargetTeamRegion(
DeviceId, TgtEntryPtr, TgtArgs, TgtOffsets, KernelArgs->NumArgs,
KernelArgs->NumTeams[0], KernelArgs->ThreadLimit[0],
KernelArgs->Tripcount);
}
// Exposed library API function
#ifdef __cplusplus
}
#endif
|
