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
122
123
124
125
126
127
128
129
130
131
132
133
|
//===----------------- Utils.h - Utilities for Remote RTL -----------------===//
//
// 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
//
//===----------------------------------------------------------------------===//
//
// Utilities for data transfer through protobuf and debugging.
//
//===----------------------------------------------------------------------===//
#ifndef UTILS_H
#define UTILS_H
#include "Debug.h"
#include "omptarget.h"
#include "openmp.grpc.pb.h"
#include "openmp.pb.h"
#include "rtl.h"
#include <string>
#define CLIENT_DBG(...) \
{ \
if (DebugLevel > 0) { \
fprintf(stderr, "[[Client]] --> "); \
fprintf(stderr, __VA_ARGS__); \
fprintf(stderr, "\n"); \
} \
}
#define SERVER_DBG(...) \
{ \
if (DebugLevel > 0) { \
fprintf(stderr, "[[Server]] --> "); \
fprintf(stderr, __VA_ARGS__); \
fprintf(stderr, "\n"); \
} \
}
namespace RemoteOffloading {
using namespace openmp::libomptarget::remote;
using openmp::libomptarget::remote::DeviceOffloadEntry;
using openmp::libomptarget::remote::TargetBinaryDescription;
using openmp::libomptarget::remote::TargetOffloadEntry;
using openmp::libomptarget::remote::TargetTable;
struct ClientManagerConfigTy {
std::vector<std::string> ServerAddresses;
uint64_t MaxSize;
uint64_t BlockSize;
int Timeout;
ClientManagerConfigTy()
: ServerAddresses({"0.0.0.0:50051"}), MaxSize(1 << 30),
BlockSize(1 << 20), Timeout(5) {
// TODO: Error handle for incorrect inputs
if (const char *Env = std::getenv("LIBOMPTARGET_RPC_ADDRESS")) {
ServerAddresses.clear();
std::string AddressString = Env;
const std::string Delimiter = ",";
size_t Pos;
std::string Token;
while ((Pos = AddressString.find(Delimiter)) != std::string::npos) {
Token = AddressString.substr(0, Pos);
ServerAddresses.push_back(Token);
AddressString.erase(0, Pos + Delimiter.length());
}
ServerAddresses.push_back(AddressString);
}
if (const char *Env = std::getenv("LIBOMPTARGET_RPC_ALLOCATOR_MAX"))
MaxSize = std::stoi(Env);
if (const char *Env = std::getenv("LIBOMPTARGET_RPC_BLOCK_SIZE"))
BlockSize = std::stoi(Env);
if (const char *Env1 = std::getenv("LIBOMPTARGET_RPC_LATENCY"))
Timeout = std::stoi(Env1);
}
};
/// Loads a target binary description into protobuf.
void loadTargetBinaryDescription(const __tgt_bin_desc *Desc,
TargetBinaryDescription &Request);
/// Unload a target binary description from protobuf. The map is used to keep
/// track of already copied device images.
void unloadTargetBinaryDescription(
const TargetBinaryDescription *Request, __tgt_bin_desc *Desc,
std::unordered_map<const void *, __tgt_device_image *>
&HostToRemoteDeviceImage);
/// Frees argument as constructed by loadTargetBinaryDescription
void freeTargetBinaryDescription(__tgt_bin_desc *Desc);
/// Copies from TargetOffloadEntry protobuf to a tgt_bin_desc during unloading.
void copyOffloadEntry(const TargetOffloadEntry &EntryResponse,
__tgt_offload_entry *Entry);
/// Copies from tgt_bin_desc into TargetOffloadEntry protobuf during loading.
void copyOffloadEntry(const __tgt_offload_entry *Entry,
TargetOffloadEntry *EntryResponse);
/// Shallow copy of offload entry from tgt_bin_desc to TargetOffloadEntry
/// during loading.
void shallowCopyOffloadEntry(const __tgt_offload_entry *Entry,
TargetOffloadEntry *EntryResponse);
/// Copies DeviceOffloadEntries into table during unloading.
void copyOffloadEntry(const DeviceOffloadEntry &EntryResponse,
__tgt_offload_entry *Entry);
/// Loads tgt_target_table into a TargetTable protobuf message.
void loadTargetTable(__tgt_target_table *Table, TargetTable &TableResponse,
__tgt_device_image *Image);
/// Unloads from a target_table from protobuf.
void unloadTargetTable(
TargetTable &TableResponse, __tgt_target_table *Table,
std::unordered_map<void *, void *> &HostToRemoteTargetTableMap);
/// Frees argument as constructed by unloadTargetTable
void freeTargetTable(__tgt_target_table *Table);
void dump(const void *Start, const void *End);
void dump(__tgt_offload_entry *Entry);
void dump(TargetOffloadEntry Entry);
void dump(__tgt_target_table *Table);
void dump(__tgt_device_image *Image);
} // namespace RemoteOffloading
#endif
|
