ec8f4a38c8
This introduces a remote offloading plugin for libomptarget. This implementation relies on gRPC and protobuf, so this library will only build if both libraries are available on the system. The corresponding server is compiled to `openmp-offloading-server`. This is a large change, but the only way to split this up is into RTL/server but I fear that could introduce an inconsistency amongst them. Ideally, tests for this should be added to the current ones that but that is problematic for at least one reason. Given that libomptarget registers plugin on a first-come-first-serve basis, if we wanted to offload onto a local x86 through a different process, then we'd have to either re-order the plugin list in `rtl.cpp` (which is what I did locally for testing) or find a better solution for runtime plugin registration in libomptarget. Differential Revision: https://reviews.llvm.org/D95314
115 lines
4.5 KiB
C++
115 lines
4.5 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 RPCConfig {
|
|
std::vector<std::string> ServerAddresses;
|
|
uint64_t MaxSize;
|
|
uint64_t BlockSize;
|
|
RPCConfig() {
|
|
ServerAddresses = {"0.0.0.0:50051"};
|
|
MaxSize = 1 << 30;
|
|
BlockSize = 1 << 20;
|
|
}
|
|
};
|
|
|
|
/// Helper function to parse common environment variables between client/server
|
|
void parseEnvironment(RPCConfig &Config);
|
|
|
|
/// 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
|