21e92612c0
D97883 introduced a compile-time error in the experimental remote offloading libomptarget plugin, this patch fixes it and resolves a number of inconsistencies in the plugin as well: 1. Non-functional Asynchronous API 2. Unnecessarily verbose debug printing 3. Misc. code clean ups This is not intended to make any functional changes to the plugin. Differential Revision: https://reviews.llvm.org/D105325
134 lines
5.3 KiB
C++
134 lines
5.3 KiB
C++
//===----------------- 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
|