[Openmp-commits] [openmp] 21e9261 - [Libomptarget] Experimental Remote Plugin Fixes
Atmn Patel via Openmp-commits
openmp-commits at lists.llvm.org
Fri Jul 2 09:39:05 PDT 2021
Author: Atmn Patel
Date: 2021-07-02T12:38:34-04:00
New Revision: 21e92612c006ef8aa2744f5fff6d0a060e6524e3
URL: https://github.com/llvm/llvm-project/commit/21e92612c006ef8aa2744f5fff6d0a060e6524e3
DIFF: https://github.com/llvm/llvm-project/commit/21e92612c006ef8aa2744f5fff6d0a060e6524e3.diff
LOG: [Libomptarget] Experimental Remote Plugin Fixes
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
Added:
Modified:
openmp/libomptarget/plugins/remote/include/Utils.h
openmp/libomptarget/plugins/remote/include/openmp.proto
openmp/libomptarget/plugins/remote/lib/Utils.cpp
openmp/libomptarget/plugins/remote/server/OffloadingServer.cpp
openmp/libomptarget/plugins/remote/server/Server.cpp
openmp/libomptarget/plugins/remote/server/Server.h
openmp/libomptarget/plugins/remote/src/Client.cpp
openmp/libomptarget/plugins/remote/src/Client.h
openmp/libomptarget/plugins/remote/src/rtl.cpp
Removed:
################################################################################
diff --git a/openmp/libomptarget/plugins/remote/include/Utils.h b/openmp/libomptarget/plugins/remote/include/Utils.h
index ca31f03f51288..15d5eafa900f0 100644
--- a/openmp/libomptarget/plugins/remote/include/Utils.h
+++ b/openmp/libomptarget/plugins/remote/include/Utils.h
@@ -47,20 +47,39 @@ using openmp::libomptarget::remote::TargetBinaryDescription;
using openmp::libomptarget::remote::TargetOffloadEntry;
using openmp::libomptarget::remote::TargetTable;
-struct RPCConfig {
+struct ClientManagerConfigTy {
std::vector<std::string> ServerAddresses;
uint64_t MaxSize;
uint64_t BlockSize;
- RPCConfig() {
- ServerAddresses = {"0.0.0.0:50051"};
- MaxSize = 1 << 30;
- BlockSize = 1 << 20;
+ 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);
}
};
-/// 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);
diff --git a/openmp/libomptarget/plugins/remote/include/openmp.proto b/openmp/libomptarget/plugins/remote/include/openmp.proto
index 1a940bddfe507..8c22be3afeb78 100644
--- a/openmp/libomptarget/plugins/remote/include/openmp.proto
+++ b/openmp/libomptarget/plugins/remote/include/openmp.proto
@@ -16,19 +16,18 @@ service RemoteOffload {
rpc InitRequires(I64) returns (I32) {}
rpc LoadBinary(Binary) returns (TargetTable) {}
- rpc Synchronize(SynchronizeDevice) returns (I32) {}
rpc DataAlloc(AllocData) returns (Pointer) {}
rpc DataDelete(DeleteData) returns (I32) {}
- rpc DataSubmitAsync(stream SubmitDataAsync) returns (I32) {}
- rpc DataRetrieveAsync(RetrieveDataAsync) returns (stream Data) {}
+ rpc DataSubmit(stream SubmitData) returns (I32) {}
+ rpc DataRetrieve(RetrieveData) returns (stream Data) {}
rpc IsDataExchangeable(DevicePair) returns (I32) {}
- rpc DataExchangeAsync(ExchangeDataAsync) returns (I32) {}
+ rpc DataExchange(ExchangeData) returns (I32) {}
- rpc RunTargetRegionAsync(TargetRegionAsync) returns (I32) {}
- rpc RunTargetTeamRegionAsync(TargetTeamRegionAsync) returns (I32) {}
+ rpc RunTargetRegion(TargetRegion) returns (I32) {}
+ rpc RunTargetTeamRegion(TargetTeamRegion) returns (I32) {}
}
message Null {}
@@ -92,32 +91,25 @@ message TargetBinaryDescription {
uint64 bin_ptr = 5;
}
-message SynchronizeDevice {
- uint64 queue_ptr = 1;
- int32 device_id = 2;
-}
-
message AllocData {
uint64 size = 1;
uint64 hst_ptr = 2;
int32 device_id = 3;
}
-message SubmitDataAsync {
+message SubmitData {
bytes data = 1;
uint64 hst_ptr = 2;
uint64 tgt_ptr = 3;
- uint64 queue_ptr = 4;
uint64 start = 5;
uint64 size = 6;
int32 device_id = 7;
}
-message RetrieveDataAsync {
+message RetrieveData {
uint64 hst_ptr = 1;
uint64 tgt_ptr = 2;
uint64 size = 3;
- uint64 queue_ptr = 4;
int32 device_id = 5;
}
@@ -128,12 +120,11 @@ message Data {
int32 ret = 4;
}
-message ExchangeDataAsync {
+message ExchangeData {
uint64 src_dev_id = 1;
uint64 src_ptr = 2;
uint64 dst_dev_id = 3;
uint64 dst_ptr = 4;
- uint64 queue_ptr = 5;
uint64 size = 6;
}
@@ -142,23 +133,21 @@ message DeleteData {
int32 device_id = 2;
}
-message TargetRegionAsync {
+message TargetRegion {
repeated uint64 tgt_args = 1;
repeated int64 tgt_offsets = 2;
uint64 tgt_entry_ptr = 3;
- uint64 queue_ptr = 4;
- int32 device_id = 5;
- int32 arg_num = 6;
+ int32 device_id = 4;
+ int32 arg_num = 5;
}
-message TargetTeamRegionAsync {
+message TargetTeamRegion {
repeated uint64 tgt_args = 1;
repeated int64 tgt_offsets = 2;
uint64 tgt_entry_ptr = 3;
uint64 loop_tripcount = 4;
- uint64 queue_ptr = 5;
- int32 device_id = 6;
- int32 arg_num = 7;
- int32 team_num = 8;
- int32 thread_limit = 9;
+ int32 device_id = 5;
+ int32 arg_num = 6;
+ int32 team_num = 7;
+ int32 thread_limit = 8;
}
diff --git a/openmp/libomptarget/plugins/remote/lib/Utils.cpp b/openmp/libomptarget/plugins/remote/lib/Utils.cpp
index 5bdd2b82a6c6f..5f1eb2950b5a6 100644
--- a/openmp/libomptarget/plugins/remote/lib/Utils.cpp
+++ b/openmp/libomptarget/plugins/remote/lib/Utils.cpp
@@ -14,27 +14,6 @@
#include "omptarget.h"
namespace RemoteOffloading {
-void parseEnvironment(RPCConfig &Config) {
- // TODO: Error handle for incorrect inputs
- if (const char *Env = std::getenv("LIBOMPTARGET_RPC_ADDRESS")) {
- Config.ServerAddresses.clear();
- std::string AddressString = Env;
- const std::string Delimiter = ",";
-
- size_t Pos = 0;
- std::string Token;
- while ((Pos = AddressString.find(Delimiter)) != std::string::npos) {
- Token = AddressString.substr(0, Pos);
- Config.ServerAddresses.push_back(Token);
- AddressString.erase(0, Pos + Delimiter.length());
- }
- Config.ServerAddresses.push_back(AddressString);
- }
- if (const char *Env = std::getenv("LIBOMPTARGET_RPC_ALLOCATOR_MAX"))
- Config.MaxSize = std::stoi(Env);
- if (const char *Env = std::getenv("LIBOMPTARGET_RPC_BLOCK_SIZE"))
- Config.BlockSize = std::stoi(Env);
-}
void loadTargetBinaryDescription(const __tgt_bin_desc *Desc,
TargetBinaryDescription &Request) {
@@ -101,10 +80,12 @@ void unloadTargetBinaryDescription(
// Copy Global Offload Entries
__tgt_offload_entry *CurEntry = Desc->HostEntriesBegin;
- for (int i = 0; i < Request->entries_size(); i++) {
- copyOffloadEntry(Request->entries()[i], CurEntry);
- CopiedOffloadEntries[(void *)Request->entry_ptrs()[i]] = CurEntry;
+ size_t I = 0;
+ for (auto &Entry : Request->entries()) {
+ copyOffloadEntry(Entry, CurEntry);
+ CopiedOffloadEntries[(void *)Request->entry_ptrs()[I]] = CurEntry;
CurEntry++;
+ I++;
}
Desc->HostEntriesEnd = CurEntry;
@@ -113,7 +94,7 @@ void unloadTargetBinaryDescription(
auto ImageItr = Request->image_ptrs().begin();
for (auto Image : Request->images()) {
// Copy Device Offload Entries
- auto *CurEntry = Desc->HostEntriesBegin;
+ CurEntry = Desc->HostEntriesBegin;
bool Found = false;
if (!Desc->HostEntriesBegin) {
@@ -121,21 +102,19 @@ void unloadTargetBinaryDescription(
CurImage->EntriesEnd = nullptr;
}
- for (int i = 0; i < Image.entries_size(); i++) {
+ for (size_t I = 0; I < Image.entries_size(); I++) {
auto TgtEntry =
- CopiedOffloadEntries.find((void *)Request->entry_ptrs()[i]);
+ CopiedOffloadEntries.find((void *)Request->entry_ptrs()[I]);
if (TgtEntry != CopiedOffloadEntries.end()) {
if (!Found)
CurImage->EntriesBegin = CurEntry;
+ CurImage->EntriesEnd = CurEntry + 1;
Found = true;
- if (Found) {
- CurImage->EntriesEnd = CurEntry + 1;
- }
} else {
Found = false;
- copyOffloadEntry(Image.entries()[i], CurEntry);
- CopiedOffloadEntries[(void *)(Request->entry_ptrs()[i])] = CurEntry;
+ copyOffloadEntry(Image.entries()[I], CurEntry);
+ CopiedOffloadEntries[(void *)(Request->entry_ptrs()[I])] = CurEntry;
}
CurEntry++;
}
@@ -199,10 +178,10 @@ void unloadTargetTable(
Table->EntriesBegin = new __tgt_offload_entry[TableResponse.entries_size()];
auto *CurEntry = Table->EntriesBegin;
- for (int i = 0; i < TableResponse.entries_size(); i++) {
- copyOffloadEntry(TableResponse.entries()[i], CurEntry);
+ for (size_t I = 0; I < TableResponse.entries_size(); I++) {
+ copyOffloadEntry(TableResponse.entries()[I], CurEntry);
HostToRemoteTargetTableMap[CurEntry->addr] =
- (void *)TableResponse.entry_ptrs()[i];
+ (void *)TableResponse.entry_ptrs()[I];
CurEntry++;
}
Table->EntriesEnd = CurEntry;
@@ -292,10 +271,10 @@ void dump(__tgt_target_table *Table) {
void dump(TargetOffloadEntry Entry) {
fprintf(stderr, "Entry: ");
- fprintf(stderr, " %s\n", Entry.name().c_str());
- fprintf(stderr, " %d\n", Entry.reserved());
- fprintf(stderr, " %d\n", Entry.flags());
- fprintf(stderr, " %ld\n", Entry.data().size());
+ fprintf(stderr, " Name: %s\n", Entry.name().c_str());
+ fprintf(stderr, " Reserved: %d\n", Entry.reserved());
+ fprintf(stderr, " Flags: %d\n", Entry.flags());
+ fprintf(stderr, " Size: %ld\n", Entry.data().size());
dump(static_cast<const void *>(Entry.data().data()),
static_cast<const void *>((Entry.data().c_str() + Entry.data().size())));
}
diff --git a/openmp/libomptarget/plugins/remote/server/OffloadingServer.cpp b/openmp/libomptarget/plugins/remote/server/OffloadingServer.cpp
index ff373b828bad2..55c4c31fd5624 100644
--- a/openmp/libomptarget/plugins/remote/server/OffloadingServer.cpp
+++ b/openmp/libomptarget/plugins/remote/server/OffloadingServer.cpp
@@ -24,8 +24,7 @@ using grpc::ServerBuilder;
std::promise<void> ShutdownPromise;
int main() {
- RPCConfig Config;
- parseEnvironment(Config);
+ ClientManagerConfigTy Config;
RemoteOffloadImpl Service(Config.MaxSize, Config.BlockSize);
diff --git a/openmp/libomptarget/plugins/remote/server/Server.cpp b/openmp/libomptarget/plugins/remote/server/Server.cpp
index 5bf8200988c56..340f44a5ef187 100644
--- a/openmp/libomptarget/plugins/remote/server/Server.cpp
+++ b/openmp/libomptarget/plugins/remote/server/Server.cpp
@@ -24,7 +24,7 @@ extern std::promise<void> ShutdownPromise;
Status RemoteOffloadImpl::Shutdown(ServerContext *Context, const Null *Request,
I32 *Reply) {
- SERVER_DBG("Shutting down the server");
+ SERVER_DBG("Shutting down the server")
Reply->set_number(0);
ShutdownPromise.set_value();
@@ -35,8 +35,6 @@ Status
RemoteOffloadImpl::RegisterLib(ServerContext *Context,
const TargetBinaryDescription *Description,
I32 *Reply) {
- SERVER_DBG("Registering library");
-
auto Desc = std::make_unique<__tgt_bin_desc>();
unloadTargetBinaryDescription(Description, Desc.get(),
@@ -49,15 +47,13 @@ RemoteOffloadImpl::RegisterLib(ServerContext *Context,
else
Descriptions[(void *)Description->bin_ptr()] = std::move(Desc);
- SERVER_DBG("Registered library");
+ SERVER_DBG("Registered library")
Reply->set_number(0);
return Status::OK;
}
Status RemoteOffloadImpl::UnregisterLib(ServerContext *Context,
const Pointer *Request, I32 *Reply) {
- SERVER_DBG("Unregistering library");
-
if (Descriptions.find((void *)Request->number()) == Descriptions.end()) {
Reply->set_number(1);
return Status::OK;
@@ -67,7 +63,7 @@ Status RemoteOffloadImpl::UnregisterLib(ServerContext *Context,
freeTargetBinaryDescription(Descriptions[(void *)Request->number()].get());
Descriptions.erase((void *)Request->number());
- SERVER_DBG("Unregistered library");
+ SERVER_DBG("Unregistered library")
Reply->set_number(0);
return Status::OK;
}
@@ -75,9 +71,6 @@ Status RemoteOffloadImpl::UnregisterLib(ServerContext *Context,
Status RemoteOffloadImpl::IsValidBinary(ServerContext *Context,
const TargetDeviceImagePtr *DeviceImage,
I32 *IsValid) {
- SERVER_DBG("Checking if binary (%p) is valid",
- (void *)(DeviceImage->image_ptr()));
-
__tgt_device_image *Image =
HostToRemoteDeviceImage[(void *)DeviceImage->image_ptr()];
@@ -90,14 +83,13 @@ Status RemoteOffloadImpl::IsValidBinary(ServerContext *Context,
}
SERVER_DBG("Checked if binary (%p) is valid",
- (void *)(DeviceImage->image_ptr()));
+ (void *)(DeviceImage->image_ptr()))
return Status::OK;
}
Status RemoteOffloadImpl::GetNumberOfDevices(ServerContext *Context,
const Null *Null,
I32 *NumberOfDevices) {
- SERVER_DBG("Getting number of devices");
std::call_once(PM->RTLs.initFlag, &RTLsTy::LoadRTLs, &PM->RTLs);
int32_t Devices = 0;
@@ -108,39 +100,32 @@ Status RemoteOffloadImpl::GetNumberOfDevices(ServerContext *Context,
NumberOfDevices->set_number(Devices);
- SERVER_DBG("Got number of devices");
+ SERVER_DBG("Got number of devices")
return Status::OK;
}
Status RemoteOffloadImpl::InitDevice(ServerContext *Context,
const I32 *DeviceNum, I32 *Reply) {
- SERVER_DBG("Initializing device %d", DeviceNum->number());
-
Reply->set_number(PM->Devices[DeviceNum->number()].RTL->init_device(
mapHostRTLDeviceId(DeviceNum->number())));
- SERVER_DBG("Initialized device %d", DeviceNum->number());
+ SERVER_DBG("Initialized device %d", DeviceNum->number())
return Status::OK;
}
Status RemoteOffloadImpl::InitRequires(ServerContext *Context,
const I64 *RequiresFlag, I32 *Reply) {
- SERVER_DBG("Initializing requires for devices");
-
for (auto &Device : PM->Devices)
if (Device.RTL->init_requires)
Device.RTL->init_requires(RequiresFlag->number());
Reply->set_number(RequiresFlag->number());
- SERVER_DBG("Initialized requires for devices");
+ SERVER_DBG("Initialized requires for devices")
return Status::OK;
}
Status RemoteOffloadImpl::LoadBinary(ServerContext *Context,
const Binary *Binary, TargetTable *Reply) {
- SERVER_DBG("Loading binary (%p) to device %d", (void *)Binary->image_ptr(),
- Binary->device_id());
-
__tgt_device_image *Image =
HostToRemoteDeviceImage[(void *)Binary->image_ptr()];
@@ -150,32 +135,13 @@ Status RemoteOffloadImpl::LoadBinary(ServerContext *Context,
loadTargetTable(Table, *Reply, Image);
SERVER_DBG("Loaded binary (%p) to device %d", (void *)Binary->image_ptr(),
- Binary->device_id());
- return Status::OK;
-}
-
-Status RemoteOffloadImpl::Synchronize(ServerContext *Context,
- const SynchronizeDevice *Info,
- I32 *Reply) {
- SERVER_DBG("Synchronizing device %d (probably won't work)",
- Info->device_id());
-
- void *AsyncInfo = (void *)Info->queue_ptr();
- Reply->set_number(0);
- if (PM->Devices[Info->device_id()].RTL->synchronize)
- Reply->set_number(PM->Devices[Info->device_id()].synchronize(
- (__tgt_async_info *)AsyncInfo));
-
- SERVER_DBG("Synchronized device %d", Info->device_id());
+ Binary->device_id())
return Status::OK;
}
Status RemoteOffloadImpl::IsDataExchangeable(ServerContext *Context,
const DevicePair *Request,
I32 *Reply) {
- SERVER_DBG("Checking if data exchangable between device %d and device %d",
- Request->src_dev_id(), Request->dst_dev_id());
-
Reply->set_number(-1);
if (PM->Devices[mapHostRTLDeviceId(Request->src_dev_id())]
.RTL->is_data_exchangable)
@@ -183,40 +149,30 @@ Status RemoteOffloadImpl::IsDataExchangeable(ServerContext *Context,
.RTL->is_data_exchangable(Request->src_dev_id(),
Request->dst_dev_id()));
- SERVER_DBG("Checked if data exchangable between device %d and device %d",
- Request->src_dev_id(), Request->dst_dev_id());
+ SERVER_DBG("Checked if data exchangeable between device %d and device %d",
+ Request->src_dev_id(), Request->dst_dev_id())
return Status::OK;
}
Status RemoteOffloadImpl::DataAlloc(ServerContext *Context,
const AllocData *Request, Pointer *Reply) {
- SERVER_DBG("Allocating %ld bytes on sevice %d", Request->size(),
- Request->device_id());
-
uint64_t TgtPtr = (uint64_t)PM->Devices[Request->device_id()].RTL->data_alloc(
mapHostRTLDeviceId(Request->device_id()), Request->size(),
- (void *)Request->hst_ptr());
+ (void *)Request->hst_ptr(), TARGET_ALLOC_DEFAULT);
Reply->set_number(TgtPtr);
- SERVER_DBG("Allocated at " DPxMOD "", DPxPTR((void *)TgtPtr));
+ SERVER_DBG("Allocated at " DPxMOD "", DPxPTR((void *)TgtPtr))
return Status::OK;
}
-Status RemoteOffloadImpl::DataSubmitAsync(ServerContext *Context,
- ServerReader<SubmitDataAsync> *Reader,
- I32 *Reply) {
- SubmitDataAsync Request;
+Status RemoteOffloadImpl::DataSubmit(ServerContext *Context,
+ ServerReader<SubmitData> *Reader,
+ I32 *Reply) {
+ SubmitData Request;
uint8_t *HostCopy = nullptr;
while (Reader->Read(&Request)) {
if (Request.start() == 0 && Request.size() == Request.data().size()) {
- SERVER_DBG("Submitting %lu bytes async to (%p) on device %d",
- Request.data().size(), (void *)Request.tgt_ptr(),
- Request.device_id());
-
- SERVER_DBG(" Host Pointer Info: %p, %p", (void *)Request.hst_ptr(),
- static_cast<const void *>(Request.data().data()));
-
Reader->SendInitialMetadata();
Reply->set_number(PM->Devices[Request.device_id()].RTL->data_submit(
@@ -225,7 +181,7 @@ Status RemoteOffloadImpl::DataSubmitAsync(ServerContext *Context,
SERVER_DBG("Submitted %lu bytes async to (%p) on device %d",
Request.data().size(), (void *)Request.tgt_ptr(),
- Request.device_id());
+ Request.device_id())
return Status::OK;
}
@@ -234,15 +190,9 @@ Status RemoteOffloadImpl::DataSubmitAsync(ServerContext *Context,
Reader->SendInitialMetadata();
}
- SERVER_DBG("Submitting %lu-%lu/%lu bytes async to (%p) on device %d",
- Request.start(), Request.start() + Request.data().size(),
- Request.size(), (void *)Request.tgt_ptr(), Request.device_id());
-
memcpy((void *)((char *)HostCopy + Request.start()), Request.data().data(),
Request.data().size());
}
- SERVER_DBG(" Host Pointer Info: %p, %p", (void *)Request.hst_ptr(),
- static_cast<const void *>(Request.data().data()));
Reply->set_number(PM->Devices[Request.device_id()].RTL->data_submit(
mapHostRTLDeviceId(Request.device_id()), (void *)Request.tgt_ptr(),
@@ -251,15 +201,16 @@ Status RemoteOffloadImpl::DataSubmitAsync(ServerContext *Context,
delete[] HostCopy;
SERVER_DBG("Submitted %lu bytes to (%p) on device %d", Request.data().size(),
- (void *)Request.tgt_ptr(), Request.device_id());
+ (void *)Request.tgt_ptr(), Request.device_id())
return Status::OK;
}
-Status RemoteOffloadImpl::DataRetrieveAsync(ServerContext *Context,
- const RetrieveDataAsync *Request,
- ServerWriter<Data> *Writer) {
+Status RemoteOffloadImpl::DataRetrieve(ServerContext *Context,
+ const RetrieveData *Request,
+ ServerWriter<Data> *Writer) {
auto HstPtr = std::make_unique<char[]>(Request->size());
+
auto Ret = PM->Devices[Request->device_id()].RTL->data_retrieve(
mapHostRTLDeviceId(Request->device_id()), HstPtr.get(),
(void *)Request->tgt_ptr(), Request->size());
@@ -277,17 +228,13 @@ Status RemoteOffloadImpl::DataRetrieveAsync(ServerContext *Context,
Reply->set_data((char *)HstPtr.get() + Start, End - Start);
Reply->set_ret(Ret);
- SERVER_DBG("Retrieving %lu-%lu/%lu bytes from (%p) on device %d", Start,
- End, Request->size(), (void *)Request->tgt_ptr(),
- mapHostRTLDeviceId(Request->device_id()));
-
if (!Writer->Write(*Reply)) {
- CLIENT_DBG("Broken stream when submitting data");
+ CLIENT_DBG("Broken stream when submitting data")
}
SERVER_DBG("Retrieved %lu-%lu/%lu bytes from (%p) on device %d", Start,
End, Request->size(), (void *)Request->tgt_ptr(),
- mapHostRTLDeviceId(Request->device_id()));
+ mapHostRTLDeviceId(Request->device_id()))
Start += BlockSize;
End += BlockSize;
@@ -297,10 +244,6 @@ Status RemoteOffloadImpl::DataRetrieveAsync(ServerContext *Context,
} else {
auto *Reply = protobuf::Arena::CreateMessage<Data>(Arena.get());
- SERVER_DBG("Retrieve %lu bytes from (%p) on device %d", Request->size(),
- (void *)Request->tgt_ptr(),
- mapHostRTLDeviceId(Request->device_id()));
-
Reply->set_start(0);
Reply->set_size(Request->size());
Reply->set_data((char *)HstPtr.get(), Request->size());
@@ -308,7 +251,7 @@ Status RemoteOffloadImpl::DataRetrieveAsync(ServerContext *Context,
SERVER_DBG("Retrieved %lu bytes from (%p) on device %d", Request->size(),
(void *)Request->tgt_ptr(),
- mapHostRTLDeviceId(Request->device_id()));
+ mapHostRTLDeviceId(Request->device_id()))
Writer->WriteLast(*Reply, WriteOptions());
}
@@ -316,16 +259,9 @@ Status RemoteOffloadImpl::DataRetrieveAsync(ServerContext *Context,
return Status::OK;
}
-Status RemoteOffloadImpl::DataExchangeAsync(ServerContext *Context,
- const ExchangeDataAsync *Request,
- I32 *Reply) {
- SERVER_DBG(
- "Exchanging data asynchronously from device %d (%p) to device %d (%p) of "
- "size %lu",
- mapHostRTLDeviceId(Request->src_dev_id()), (void *)Request->src_ptr(),
- mapHostRTLDeviceId(Request->dst_dev_id()), (void *)Request->dst_ptr(),
- Request->size());
-
+Status RemoteOffloadImpl::DataExchange(ServerContext *Context,
+ const ExchangeData *Request,
+ I32 *Reply) {
if (PM->Devices[Request->src_dev_id()].RTL->data_exchange) {
int32_t Ret = PM->Devices[Request->src_dev_id()].RTL->data_exchange(
mapHostRTLDeviceId(Request->src_dev_id()), (void *)Request->src_ptr(),
@@ -340,30 +276,24 @@ Status RemoteOffloadImpl::DataExchangeAsync(ServerContext *Context,
"size %lu",
mapHostRTLDeviceId(Request->src_dev_id()), (void *)Request->src_ptr(),
mapHostRTLDeviceId(Request->dst_dev_id()), (void *)Request->dst_ptr(),
- Request->size());
+ Request->size())
return Status::OK;
}
Status RemoteOffloadImpl::DataDelete(ServerContext *Context,
const DeleteData *Request, I32 *Reply) {
- SERVER_DBG("Deleting data from (%p) on device %d", (void *)Request->tgt_ptr(),
- mapHostRTLDeviceId(Request->device_id()));
-
auto Ret = PM->Devices[Request->device_id()].RTL->data_delete(
mapHostRTLDeviceId(Request->device_id()), (void *)Request->tgt_ptr());
Reply->set_number(Ret);
SERVER_DBG("Deleted data from (%p) on device %d", (void *)Request->tgt_ptr(),
- mapHostRTLDeviceId(Request->device_id()));
+ mapHostRTLDeviceId(Request->device_id()))
return Status::OK;
}
-Status RemoteOffloadImpl::RunTargetRegionAsync(ServerContext *Context,
- const TargetRegionAsync *Request,
- I32 *Reply) {
- SERVER_DBG("Running TargetRegionAsync on device %d with %d args",
- mapHostRTLDeviceId(Request->device_id()), Request->arg_num());
-
+Status RemoteOffloadImpl::RunTargetRegion(ServerContext *Context,
+ const TargetRegion *Request,
+ I32 *Reply) {
std::vector<uint8_t> TgtArgs(Request->arg_num());
for (auto I = 0; I < Request->arg_num(); I++)
TgtArgs[I] = (uint64_t)Request->tgt_args()[I];
@@ -381,16 +311,14 @@ Status RemoteOffloadImpl::RunTargetRegionAsync(ServerContext *Context,
Reply->set_number(Ret);
- SERVER_DBG("Ran TargetRegionAsync on device %d with %d args",
- mapHostRTLDeviceId(Request->device_id()), Request->arg_num());
+ SERVER_DBG("Ran TargetRegion on device %d with %d args",
+ mapHostRTLDeviceId(Request->device_id()), Request->arg_num())
return Status::OK;
}
-Status RemoteOffloadImpl::RunTargetTeamRegionAsync(
- ServerContext *Context, const TargetTeamRegionAsync *Request, I32 *Reply) {
- SERVER_DBG("Running TargetTeamRegionAsync on device %d with %d args",
- mapHostRTLDeviceId(Request->device_id()), Request->arg_num());
-
+Status RemoteOffloadImpl::RunTargetTeamRegion(ServerContext *Context,
+ const TargetTeamRegion *Request,
+ I32 *Reply) {
std::vector<uint64_t> TgtArgs(Request->arg_num());
for (auto I = 0; I < Request->arg_num(); I++)
TgtArgs[I] = (uint64_t)Request->tgt_args()[I];
@@ -401,6 +329,7 @@ Status RemoteOffloadImpl::RunTargetTeamRegionAsync(
TgtOffsets[I] = (ptr
diff _t)*TgtOffsetItr;
void *TgtEntryPtr = ((__tgt_offload_entry *)Request->tgt_entry_ptr())->addr;
+
int32_t Ret = PM->Devices[Request->device_id()].RTL->run_team_region(
mapHostRTLDeviceId(Request->device_id()), TgtEntryPtr,
(void **)TgtArgs.data(), TgtOffsets.data(), Request->arg_num(),
@@ -408,8 +337,8 @@ Status RemoteOffloadImpl::RunTargetTeamRegionAsync(
Reply->set_number(Ret);
- SERVER_DBG("Ran TargetTeamRegionAsync on device %d with %d args",
- mapHostRTLDeviceId(Request->device_id()), Request->arg_num());
+ SERVER_DBG("Ran TargetTeamRegion on device %d with %d args",
+ mapHostRTLDeviceId(Request->device_id()), Request->arg_num())
return Status::OK;
}
diff --git a/openmp/libomptarget/plugins/remote/server/Server.h b/openmp/libomptarget/plugins/remote/server/Server.h
index 3d20b9f177172..5414ad13913c5 100644
--- a/openmp/libomptarget/plugins/remote/server/Server.h
+++ b/openmp/libomptarget/plugins/remote/server/Server.h
@@ -40,8 +40,6 @@ class RemoteOffloadImpl final : public RemoteOffload::Service {
std::unordered_map<const void *, __tgt_device_image *>
HostToRemoteDeviceImage;
- std::unordered_map<const void *, __tgt_offload_entry *>
- HostToRemoteOffloadEntry;
std::unordered_map<const void *, std::unique_ptr<__tgt_bin_desc>>
Descriptions;
__tgt_target_table *Table = nullptr;
@@ -80,35 +78,29 @@ class RemoteOffloadImpl final : public RemoteOffload::Service {
Status LoadBinary(ServerContext *Context, const Binary *Binary,
TargetTable *Reply) override;
- Status Synchronize(ServerContext *Context, const SynchronizeDevice *Info,
- I32 *Reply) override;
Status IsDataExchangeable(ServerContext *Context, const DevicePair *Request,
I32 *Reply) override;
Status DataAlloc(ServerContext *Context, const AllocData *Request,
Pointer *Reply) override;
- Status DataSubmitAsync(ServerContext *Context,
- ServerReader<SubmitDataAsync> *Reader,
- I32 *Reply) override;
- Status DataRetrieveAsync(ServerContext *Context,
- const RetrieveDataAsync *Request,
- ServerWriter<Data> *Writer) override;
+ Status DataSubmit(ServerContext *Context, ServerReader<SubmitData> *Reader,
+ I32 *Reply) override;
+ Status DataRetrieve(ServerContext *Context, const RetrieveData *Request,
+ ServerWriter<Data> *Writer) override;
- Status DataExchangeAsync(ServerContext *Context,
- const ExchangeDataAsync *Request,
- I32 *Reply) override;
+ Status DataExchange(ServerContext *Context, const ExchangeData *Request,
+ I32 *Reply) override;
Status DataDelete(ServerContext *Context, const DeleteData *Request,
I32 *Reply) override;
- Status RunTargetRegionAsync(ServerContext *Context,
- const TargetRegionAsync *Request,
- I32 *Reply) override;
+ Status RunTargetRegion(ServerContext *Context, const TargetRegion *Request,
+ I32 *Reply) override;
- Status RunTargetTeamRegionAsync(ServerContext *Context,
- const TargetTeamRegionAsync *Request,
- I32 *Reply) override;
+ Status RunTargetTeamRegion(ServerContext *Context,
+ const TargetTeamRegion *Request,
+ I32 *Reply) override;
};
#endif
diff --git a/openmp/libomptarget/plugins/remote/src/Client.cpp b/openmp/libomptarget/plugins/remote/src/Client.cpp
index 49b595c6e7770..917acbba03478 100644
--- a/openmp/libomptarget/plugins/remote/src/Client.cpp
+++ b/openmp/libomptarget/plugins/remote/src/Client.cpp
@@ -24,31 +24,30 @@ using grpc::ClientWriter;
using grpc::Status;
template <typename Fn1, typename Fn2, typename TReturn>
-auto RemoteOffloadClient::remoteCall(Fn1 Preprocess, Fn2 Postprocess,
- TReturn ErrorValue, bool Timeout) {
+auto RemoteOffloadClient::remoteCall(Fn1 Preprocessor, Fn2 Postprocessor,
+ TReturn ErrorValue, bool CanTimeOut) {
ArenaAllocatorLock->lock();
if (Arena->SpaceAllocated() >= MaxSize)
Arena->Reset();
ArenaAllocatorLock->unlock();
ClientContext Context;
- if (Timeout) {
+ if (CanTimeOut) {
auto Deadline =
std::chrono::system_clock::now() + std::chrono::seconds(Timeout);
Context.set_deadline(Deadline);
}
Status RPCStatus;
- auto Reply = Preprocess(RPCStatus, Context);
+ auto Reply = Preprocessor(RPCStatus, Context);
- // TODO: Error handle more appropriately
if (!RPCStatus.ok()) {
- CLIENT_DBG("%s", RPCStatus.error_message().c_str());
+ CLIENT_DBG("%s", RPCStatus.error_message().c_str())
} else {
- return Postprocess(Reply);
+ return Postprocessor(Reply);
}
- CLIENT_DBG("Failed");
+ CLIENT_DBG("Failed")
return ErrorValue;
}
@@ -56,7 +55,7 @@ int32_t RemoteOffloadClient::shutdown(void) {
ClientContext Context;
Null Request;
I32 Reply;
- CLIENT_DBG("Shutting down server.");
+ CLIENT_DBG("Shutting down server.")
auto Status = Stub->Shutdown(&Context, Request, &Reply);
if (Status.ok())
return Reply.number();
@@ -65,7 +64,7 @@ int32_t RemoteOffloadClient::shutdown(void) {
int32_t RemoteOffloadClient::registerLib(__tgt_bin_desc *Desc) {
return remoteCall(
- /* Preprocess */
+ /* Preprocessor */
[&](auto &RPCStatus, auto &Context) {
auto *Request = protobuf::Arena::CreateMessage<TargetBinaryDescription>(
Arena.get());
@@ -73,14 +72,13 @@ int32_t RemoteOffloadClient::registerLib(__tgt_bin_desc *Desc) {
loadTargetBinaryDescription(Desc, *Request);
Request->set_bin_ptr((uint64_t)Desc);
- CLIENT_DBG("Registering library");
RPCStatus = Stub->RegisterLib(&Context, *Request, Reply);
return Reply;
},
- /* Postprocess */
+ /* Postprocessor */
[&](const auto &Reply) {
if (Reply->number() == 0) {
- CLIENT_DBG("Registered library");
+ CLIENT_DBG("Registered library")
return 0;
}
return 1;
@@ -90,24 +88,23 @@ int32_t RemoteOffloadClient::registerLib(__tgt_bin_desc *Desc) {
int32_t RemoteOffloadClient::unregisterLib(__tgt_bin_desc *Desc) {
return remoteCall(
- /* Preprocess */
+ /* Preprocessor */
[&](auto &RPCStatus, auto &Context) {
auto *Request = protobuf::Arena::CreateMessage<Pointer>(Arena.get());
auto *Reply = protobuf::Arena::CreateMessage<I32>(Arena.get());
Request->set_number((uint64_t)Desc);
- CLIENT_DBG("Unregistering library");
RPCStatus = Stub->UnregisterLib(&Context, *Request, Reply);
return Reply;
},
- /* Postprocess */
+ /* Postprocessor */
[&](const auto &Reply) {
if (Reply->number() == 0) {
- CLIENT_DBG("Unregistered library");
+ CLIENT_DBG("Unregistered library")
return 0;
}
- CLIENT_DBG("Failed to unregister library");
+ CLIENT_DBG("Failed to unregister library")
return 1;
},
/* Error Value */ 1);
@@ -115,7 +112,7 @@ int32_t RemoteOffloadClient::unregisterLib(__tgt_bin_desc *Desc) {
int32_t RemoteOffloadClient::isValidBinary(__tgt_device_image *Image) {
return remoteCall(
- /* Preprocess */
+ /* Preprocessor */
[&](auto &RPCStatus, auto &Context) {
auto *Request =
protobuf::Arena::CreateMessage<TargetDeviceImagePtr>(Arena.get());
@@ -127,16 +124,15 @@ int32_t RemoteOffloadClient::isValidBinary(__tgt_device_image *Image) {
while (EntryItr != Image->EntriesEnd)
Request->add_entry_ptrs((uint64_t)EntryItr++);
- CLIENT_DBG("Validating binary");
RPCStatus = Stub->IsValidBinary(&Context, *Request, Reply);
return Reply;
},
- /* Postprocess */
+ /* Postprocessor */
[&](const auto &Reply) {
if (Reply->number()) {
- CLIENT_DBG("Validated binary");
+ CLIENT_DBG("Validated binary")
} else {
- CLIENT_DBG("Could not validate binary");
+ CLIENT_DBG("Could not validate binary")
}
return Reply->number();
},
@@ -145,22 +141,21 @@ int32_t RemoteOffloadClient::isValidBinary(__tgt_device_image *Image) {
int32_t RemoteOffloadClient::getNumberOfDevices() {
return remoteCall(
- /* Preprocess */
+ /* Preprocessor */
[&](Status &RPCStatus, ClientContext &Context) {
auto *Request = protobuf::Arena::CreateMessage<Null>(Arena.get());
auto *Reply = protobuf::Arena::CreateMessage<I32>(Arena.get());
- CLIENT_DBG("Getting number of devices");
RPCStatus = Stub->GetNumberOfDevices(&Context, *Request, Reply);
return Reply;
},
- /* Postprocess */
+ /* Postprocessor */
[&](const auto &Reply) {
if (Reply->number()) {
- CLIENT_DBG("Found %d devices", Reply->number());
+ CLIENT_DBG("Found %d devices", Reply->number())
} else {
- CLIENT_DBG("Could not get the number of devices");
+ CLIENT_DBG("Could not get the number of devices")
}
return Reply->number();
},
@@ -169,24 +164,23 @@ int32_t RemoteOffloadClient::getNumberOfDevices() {
int32_t RemoteOffloadClient::initDevice(int32_t DeviceId) {
return remoteCall(
- /* Preprocess */
+ /* Preprocessor */
[&](auto &RPCStatus, auto &Context) {
auto *Request = protobuf::Arena::CreateMessage<I32>(Arena.get());
auto *Reply = protobuf::Arena::CreateMessage<I32>(Arena.get());
Request->set_number(DeviceId);
- CLIENT_DBG("Initializing device %d", DeviceId);
RPCStatus = Stub->InitDevice(&Context, *Request, Reply);
return Reply;
},
- /* Postprocess */
+ /* Postprocessor */
[&](const auto &Reply) {
if (!Reply->number()) {
- CLIENT_DBG("Initialized device %d", DeviceId);
+ CLIENT_DBG("Initialized device %d", DeviceId)
} else {
- CLIENT_DBG("Could not initialize device %d", DeviceId);
+ CLIENT_DBG("Could not initialize device %d", DeviceId)
}
return Reply->number();
},
@@ -195,21 +189,20 @@ int32_t RemoteOffloadClient::initDevice(int32_t DeviceId) {
int32_t RemoteOffloadClient::initRequires(int64_t RequiresFlags) {
return remoteCall(
- /* Preprocess */
+ /* Preprocessor */
[&](auto &RPCStatus, auto &Context) {
auto *Request = protobuf::Arena::CreateMessage<I64>(Arena.get());
auto *Reply = protobuf::Arena::CreateMessage<I32>(Arena.get());
Request->set_number(RequiresFlags);
- CLIENT_DBG("Initializing requires");
RPCStatus = Stub->InitRequires(&Context, *Request, Reply);
return Reply;
},
- /* Postprocess */
+ /* Postprocessor */
[&](const auto &Reply) {
if (Reply->number()) {
- CLIENT_DBG("Initialized requires");
+ CLIENT_DBG("Initialized requires")
} else {
- CLIENT_DBG("Could not initialize requires");
+ CLIENT_DBG("Could not initialize requires")
}
return Reply->number();
},
@@ -219,7 +212,7 @@ int32_t RemoteOffloadClient::initRequires(int64_t RequiresFlags) {
__tgt_target_table *RemoteOffloadClient::loadBinary(int32_t DeviceId,
__tgt_device_image *Image) {
return remoteCall(
- /* Preprocess */
+ /* Preprocessor */
[&](auto &RPCStatus, auto &Context) {
auto *ImageMessage =
protobuf::Arena::CreateMessage<Binary>(Arena.get());
@@ -227,14 +220,13 @@ __tgt_target_table *RemoteOffloadClient::loadBinary(int32_t DeviceId,
ImageMessage->set_image_ptr((uint64_t)Image->ImageStart);
ImageMessage->set_device_id(DeviceId);
- CLIENT_DBG("Loading Image %p to device %d", Image, DeviceId);
RPCStatus = Stub->LoadBinary(&Context, *ImageMessage, Reply);
return Reply;
},
- /* Postprocess */
+ /* Postprocessor */
[&](auto &Reply) {
if (Reply->entries_size() == 0) {
- CLIENT_DBG("Could not load image %p onto device %d", Image, DeviceId);
+ CLIENT_DBG("Could not load image %p onto device %d", Image, DeviceId)
return (__tgt_target_table *)nullptr;
}
DevicesToTables[DeviceId] = std::make_unique<__tgt_target_table>();
@@ -242,46 +234,18 @@ __tgt_target_table *RemoteOffloadClient::loadBinary(int32_t DeviceId,
RemoteEntries[DeviceId]);
CLIENT_DBG("Loaded Image %p to device %d with %d entries", Image,
- DeviceId, Reply->entries_size());
+ DeviceId, Reply->entries_size())
return DevicesToTables[DeviceId].get();
},
/* Error Value */ (__tgt_target_table *)nullptr,
- /* Timeout */ false);
-}
-
-int64_t RemoteOffloadClient::synchronize(int32_t DeviceId,
- __tgt_async_info *AsyncInfo) {
- return remoteCall(
- /* Preprocess */
- [&](auto &RPCStatus, auto &Context) {
- auto *Reply = protobuf::Arena::CreateMessage<I32>(Arena.get());
- auto *Info =
- protobuf::Arena::CreateMessage<SynchronizeDevice>(Arena.get());
-
- Info->set_device_id(DeviceId);
- Info->set_queue_ptr((uint64_t)AsyncInfo);
-
- CLIENT_DBG("Synchronizing device %d", DeviceId);
- RPCStatus = Stub->Synchronize(&Context, *Info, Reply);
- return Reply;
- },
- /* Postprocess */
- [&](auto &Reply) {
- if (Reply->number()) {
- CLIENT_DBG("Synchronized device %d", DeviceId);
- } else {
- CLIENT_DBG("Could not synchronize device %d", DeviceId);
- }
- return Reply->number();
- },
- /* Error Value */ -1);
+ /* CanTimeOut */ false);
}
int32_t RemoteOffloadClient::isDataExchangeable(int32_t SrcDevId,
int32_t DstDevId) {
return remoteCall(
- /* Preprocess */
+ /* Preprocessor */
[&](auto &RPCStatus, auto &Context) {
auto *Request = protobuf::Arena::CreateMessage<DevicePair>(Arena.get());
auto *Reply = protobuf::Arena::CreateMessage<I32>(Arena.get());
@@ -289,18 +253,16 @@ int32_t RemoteOffloadClient::isDataExchangeable(int32_t SrcDevId,
Request->set_src_dev_id(SrcDevId);
Request->set_dst_dev_id(DstDevId);
- CLIENT_DBG("Asking if data is exchangeable between %d, %d", SrcDevId,
- DstDevId);
RPCStatus = Stub->IsDataExchangeable(&Context, *Request, Reply);
return Reply;
},
- /* Postprocess */
+ /* Postprocessor */
[&](auto &Reply) {
if (Reply->number()) {
- CLIENT_DBG("Data is exchangeable between %d, %d", SrcDevId, DstDevId);
+ CLIENT_DBG("Data is exchangeable between %d, %d", SrcDevId, DstDevId)
} else {
CLIENT_DBG("Data is not exchangeable between %d, %d", SrcDevId,
- DstDevId);
+ DstDevId)
}
return Reply->number();
},
@@ -310,7 +272,7 @@ int32_t RemoteOffloadClient::isDataExchangeable(int32_t SrcDevId,
void *RemoteOffloadClient::dataAlloc(int32_t DeviceId, int64_t Size,
void *HstPtr) {
return remoteCall(
- /* Preprocess */
+ /* Preprocessor */
[&](auto &RPCStatus, auto &Context) {
auto *Reply = protobuf::Arena::CreateMessage<Pointer>(Arena.get());
auto *Request = protobuf::Arena::CreateMessage<AllocData>(Arena.get());
@@ -319,40 +281,38 @@ void *RemoteOffloadClient::dataAlloc(int32_t DeviceId, int64_t Size,
Request->set_size(Size);
Request->set_hst_ptr((uint64_t)HstPtr);
- CLIENT_DBG("Allocating %ld bytes on device %d", Size, DeviceId);
RPCStatus = Stub->DataAlloc(&Context, *Request, Reply);
return Reply;
},
- /* Postprocess */
+ /* Postprocessor */
[&](auto &Reply) {
if (Reply->number()) {
CLIENT_DBG("Allocated %ld bytes on device %d at %p", Size, DeviceId,
- (void *)Reply->number());
+ (void *)Reply->number())
} else {
CLIENT_DBG("Could not allocate %ld bytes on device %d at %p", Size,
- DeviceId, (void *)Reply->number());
+ DeviceId, (void *)Reply->number())
}
return (void *)Reply->number();
},
/* Error Value */ (void *)nullptr);
}
-int32_t RemoteOffloadClient::dataSubmitAsync(int32_t DeviceId, void *TgtPtr,
- void *HstPtr, int64_t Size,
- __tgt_async_info *AsyncInfo) {
+int32_t RemoteOffloadClient::dataSubmit(int32_t DeviceId, void *TgtPtr,
+ void *HstPtr, int64_t Size) {
return remoteCall(
- /* Preprocess */
+ /* Preprocessor */
[&](auto &RPCStatus, auto &Context) {
auto *Reply = protobuf::Arena::CreateMessage<I32>(Arena.get());
- std::unique_ptr<ClientWriter<SubmitDataAsync>> Writer(
- Stub->DataSubmitAsync(&Context, Reply));
+ std::unique_ptr<ClientWriter<SubmitData>> Writer(
+ Stub->DataSubmit(&Context, Reply));
if (Size > BlockSize) {
int64_t Start = 0, End = BlockSize;
for (auto I = 0; I < ceil((float)Size / BlockSize); I++) {
auto *Request =
- protobuf::Arena::CreateMessage<SubmitDataAsync>(Arena.get());
+ protobuf::Arena::CreateMessage<SubmitData>(Arena.get());
Request->set_device_id(DeviceId);
Request->set_data((char *)HstPtr + Start, End - Start);
@@ -360,13 +320,9 @@ int32_t RemoteOffloadClient::dataSubmitAsync(int32_t DeviceId, void *TgtPtr,
Request->set_tgt_ptr((uint64_t)TgtPtr);
Request->set_start(Start);
Request->set_size(Size);
- Request->set_queue_ptr((uint64_t)AsyncInfo);
-
- CLIENT_DBG("Submitting %ld-%ld/%ld bytes async on device %d at %p",
- Start, End, Size, DeviceId, TgtPtr)
if (!Writer->Write(*Request)) {
- CLIENT_DBG("Broken stream when submitting data");
+ CLIENT_DBG("Broken stream when submitting data")
Reply->set_number(0);
return Reply;
}
@@ -378,7 +334,7 @@ int32_t RemoteOffloadClient::dataSubmitAsync(int32_t DeviceId, void *TgtPtr,
}
} else {
auto *Request =
- protobuf::Arena::CreateMessage<SubmitDataAsync>(Arena.get());
+ protobuf::Arena::CreateMessage<SubmitData>(Arena.get());
Request->set_device_id(DeviceId);
Request->set_data(HstPtr, Size);
@@ -387,10 +343,8 @@ int32_t RemoteOffloadClient::dataSubmitAsync(int32_t DeviceId, void *TgtPtr,
Request->set_start(0);
Request->set_size(Size);
- CLIENT_DBG("Submitting %ld bytes async on device %d at %p", Size,
- DeviceId, TgtPtr)
if (!Writer->Write(*Request)) {
- CLIENT_DBG("Broken stream when submitting data");
+ CLIENT_DBG("Broken stream when submitting data")
Reply->set_number(0);
return Reply;
}
@@ -401,11 +355,11 @@ int32_t RemoteOffloadClient::dataSubmitAsync(int32_t DeviceId, void *TgtPtr,
return Reply;
},
- /* Postprocess */
+ /* Postprocessor */
[&](auto &Reply) {
if (!Reply->number()) {
- CLIENT_DBG("Async submitted %ld bytes on device %d at %p", Size,
- DeviceId, TgtPtr)
+ CLIENT_DBG(" submitted %ld bytes on device %d at %p", Size, DeviceId,
+ TgtPtr)
} else {
CLIENT_DBG("Could not async submit %ld bytes on device %d at %p",
Size, DeviceId, TgtPtr)
@@ -413,27 +367,25 @@ int32_t RemoteOffloadClient::dataSubmitAsync(int32_t DeviceId, void *TgtPtr,
return Reply->number();
},
/* Error Value */ -1,
- /* Timeout */ false);
+ /* CanTimeOut */ false);
}
-int32_t RemoteOffloadClient::dataRetrieveAsync(int32_t DeviceId, void *HstPtr,
- void *TgtPtr, int64_t Size,
- __tgt_async_info *AsyncInfo) {
+int32_t RemoteOffloadClient::dataRetrieve(int32_t DeviceId, void *HstPtr,
+ void *TgtPtr, int64_t Size) {
return remoteCall(
- /* Preprocess */
+ /* Preprocessor */
[&](auto &RPCStatus, auto &Context) {
auto *Request =
- protobuf::Arena::CreateMessage<RetrieveDataAsync>(Arena.get());
+ protobuf::Arena::CreateMessage<RetrieveData>(Arena.get());
Request->set_device_id(DeviceId);
Request->set_size(Size);
Request->set_hst_ptr((int64_t)HstPtr);
Request->set_tgt_ptr((int64_t)TgtPtr);
- Request->set_queue_ptr((uint64_t)AsyncInfo);
auto *Reply = protobuf::Arena::CreateMessage<Data>(Arena.get());
std::unique_ptr<ClientReader<Data>> Reader(
- Stub->DataRetrieveAsync(&Context, *Request));
+ Stub->DataRetrieve(&Context, *Request));
Reader->WaitForInitialMetadata();
while (Reader->Read(Reply)) {
if (Reply->ret()) {
@@ -444,18 +396,10 @@ int32_t RemoteOffloadClient::dataRetrieveAsync(int32_t DeviceId, void *HstPtr,
}
if (Reply->start() == 0 && Reply->size() == Reply->data().size()) {
- CLIENT_DBG("Async retrieving %ld bytes on device %d at %p for %p",
- Size, DeviceId, TgtPtr, HstPtr)
-
memcpy(HstPtr, Reply->data().data(), Reply->data().size());
return Reply;
}
- CLIENT_DBG("Retrieving %lu-%lu/%lu bytes async from (%p) to (%p) "
- "on Device %d",
- Reply->start(), Reply->start() + Reply->data().size(),
- Reply->size(), (void *)Request->tgt_ptr(), HstPtr,
- Request->device_id());
memcpy((void *)((char *)HstPtr + Reply->start()),
Reply->data().data(), Reply->data().size());
@@ -464,54 +408,49 @@ int32_t RemoteOffloadClient::dataRetrieveAsync(int32_t DeviceId, void *HstPtr,
return Reply;
},
- /* Postprocess */
+ /* Postprocessor */
[&](auto &Reply) {
if (!Reply->ret()) {
- CLIENT_DBG("Async retrieve %ld bytes on Device %d", Size, DeviceId);
+ CLIENT_DBG("Retrieved %ld bytes on Device %d", Size, DeviceId)
} else {
CLIENT_DBG("Could not async retrieve %ld bytes on Device %d", Size,
- DeviceId);
+ DeviceId)
}
return Reply->ret();
},
/* Error Value */ -1,
- /* Timeout */ false);
+ /* CanTimeOut */ false);
}
-int32_t RemoteOffloadClient::dataExchangeAsync(int32_t SrcDevId, void *SrcPtr,
- int32_t DstDevId, void *DstPtr,
- int64_t Size,
- __tgt_async_info *AsyncInfo) {
+int32_t RemoteOffloadClient::dataExchange(int32_t SrcDevId, void *SrcPtr,
+ int32_t DstDevId, void *DstPtr,
+ int64_t Size) {
return remoteCall(
- /* Preprocess */
+ /* Preprocessor */
[&](auto &RPCStatus, auto &Context) {
auto *Reply = protobuf::Arena::CreateMessage<I32>(Arena.get());
auto *Request =
- protobuf::Arena::CreateMessage<ExchangeDataAsync>(Arena.get());
+ protobuf::Arena::CreateMessage<ExchangeData>(Arena.get());
Request->set_src_dev_id(SrcDevId);
Request->set_src_ptr((uint64_t)SrcPtr);
Request->set_dst_dev_id(DstDevId);
Request->set_dst_ptr((uint64_t)DstPtr);
Request->set_size(Size);
- Request->set_queue_ptr((uint64_t)AsyncInfo);
- CLIENT_DBG(
- "Exchanging %ld bytes on device %d at %p for %p on device %d", Size,
- SrcDevId, SrcPtr, DstPtr, DstDevId);
- RPCStatus = Stub->DataExchangeAsync(&Context, *Request, Reply);
+ RPCStatus = Stub->DataExchange(&Context, *Request, Reply);
return Reply;
},
- /* Postprocess */
+ /* Postprocessor */
[&](auto &Reply) {
if (Reply->number()) {
CLIENT_DBG(
"Exchanged %ld bytes on device %d at %p for %p on device %d",
- Size, SrcDevId, SrcPtr, DstPtr, DstDevId);
+ Size, SrcDevId, SrcPtr, DstPtr, DstDevId)
} else {
CLIENT_DBG("Could not exchange %ld bytes on device %d at %p for %p "
"on device %d",
- Size, SrcDevId, SrcPtr, DstPtr, DstDevId);
+ Size, SrcDevId, SrcPtr, DstPtr, DstDevId)
}
return Reply->number();
},
@@ -520,7 +459,7 @@ int32_t RemoteOffloadClient::dataExchangeAsync(int32_t SrcDevId, void *SrcPtr,
int32_t RemoteOffloadClient::dataDelete(int32_t DeviceId, void *TgtPtr) {
return remoteCall(
- /* Preprocess */
+ /* Preprocessor */
[&](auto &RPCStatus, auto &Context) {
auto *Reply = protobuf::Arena::CreateMessage<I32>(Arena.get());
auto *Request = protobuf::Arena::CreateMessage<DeleteData>(Arena.get());
@@ -528,11 +467,10 @@ int32_t RemoteOffloadClient::dataDelete(int32_t DeviceId, void *TgtPtr) {
Request->set_device_id(DeviceId);
Request->set_tgt_ptr((uint64_t)TgtPtr);
- CLIENT_DBG("Deleting data at %p on device %d", TgtPtr, DeviceId)
RPCStatus = Stub->DataDelete(&Context, *Request, Reply);
return Reply;
},
- /* Postprocess */
+ /* Postprocessor */
[&](auto &Reply) {
if (!Reply->number()) {
CLIENT_DBG("Deleted data at %p on device %d", TgtPtr, DeviceId)
@@ -545,18 +483,18 @@ int32_t RemoteOffloadClient::dataDelete(int32_t DeviceId, void *TgtPtr) {
/* Error Value */ -1);
}
-int32_t RemoteOffloadClient::runTargetRegionAsync(
- int32_t DeviceId, void *TgtEntryPtr, void **TgtArgs, ptr
diff _t *TgtOffsets,
- int32_t ArgNum, __tgt_async_info *AsyncInfo) {
+int32_t RemoteOffloadClient::runTargetRegion(int32_t DeviceId,
+ void *TgtEntryPtr, void **TgtArgs,
+ ptr
diff _t *TgtOffsets,
+ int32_t ArgNum) {
return remoteCall(
- /* Preprocess */
+ /* Preprocessor */
[&](auto &RPCStatus, auto &Context) {
auto *Reply = protobuf::Arena::CreateMessage<I32>(Arena.get());
auto *Request =
- protobuf::Arena::CreateMessage<TargetRegionAsync>(Arena.get());
+ protobuf::Arena::CreateMessage<TargetRegion>(Arena.get());
Request->set_device_id(DeviceId);
- Request->set_queue_ptr((uint64_t)AsyncInfo);
Request->set_tgt_entry_ptr(
(uint64_t)RemoteEntries[DeviceId][TgtEntryPtr]);
@@ -571,37 +509,34 @@ int32_t RemoteOffloadClient::runTargetRegionAsync(
Request->set_arg_num(ArgNum);
- CLIENT_DBG("Running target region async on device %d", DeviceId);
- RPCStatus = Stub->RunTargetRegionAsync(&Context, *Request, Reply);
+ RPCStatus = Stub->RunTargetRegion(&Context, *Request, Reply);
return Reply;
},
- /* Postprocess */
+ /* Postprocessor */
[&](auto &Reply) {
if (!Reply->number()) {
- CLIENT_DBG("Ran target region async on device %d", DeviceId);
+ CLIENT_DBG("Ran target region async on device %d", DeviceId)
} else {
- CLIENT_DBG("Could not run target region async on device %d",
- DeviceId);
+ CLIENT_DBG("Could not run target region async on device %d", DeviceId)
}
return Reply->number();
},
/* Error Value */ -1,
- /* Timeout */ false);
+ /* CanTimeOut */ false);
}
-int32_t RemoteOffloadClient::runTargetTeamRegionAsync(
+int32_t RemoteOffloadClient::runTargetTeamRegion(
int32_t DeviceId, void *TgtEntryPtr, void **TgtArgs, ptr
diff _t *TgtOffsets,
int32_t ArgNum, int32_t TeamNum, int32_t ThreadLimit,
- uint64_t LoopTripcount, __tgt_async_info *AsyncInfo) {
+ uint64_t LoopTripcount) {
return remoteCall(
- /* Preprocess */
+ /* Preprocessor */
[&](auto &RPCStatus, auto &Context) {
auto *Reply = protobuf::Arena::CreateMessage<I32>(Arena.get());
auto *Request =
- protobuf::Arena::CreateMessage<TargetTeamRegionAsync>(Arena.get());
+ protobuf::Arena::CreateMessage<TargetTeamRegion>(Arena.get());
Request->set_device_id(DeviceId);
- Request->set_queue_ptr((uint64_t)AsyncInfo);
Request->set_tgt_entry_ptr(
(uint64_t)RemoteEntries[DeviceId][TgtEntryPtr]);
@@ -620,25 +555,23 @@ int32_t RemoteOffloadClient::runTargetTeamRegionAsync(
Request->set_thread_limit(ThreadLimit);
Request->set_loop_tripcount(LoopTripcount);
- CLIENT_DBG("Running target team region async on device %d", DeviceId);
- RPCStatus = Stub->RunTargetTeamRegionAsync(&Context, *Request, Reply);
+ RPCStatus = Stub->RunTargetTeamRegion(&Context, *Request, Reply);
return Reply;
},
- /* Postprocess */
+ /* Postprocessor */
[&](auto &Reply) {
if (!Reply->number()) {
- CLIENT_DBG("Ran target team region async on device %d", DeviceId);
+ CLIENT_DBG("Ran target team region async on device %d", DeviceId)
} else {
CLIENT_DBG("Could not run target team region async on device %d",
- DeviceId);
+ DeviceId)
}
return Reply->number();
},
/* Error Value */ -1,
- /* Timeout */ false);
+ /* CanTimeOut */ false);
}
-// TODO: Better error handling for the next three functions
int32_t RemoteClientManager::shutdown(void) {
int32_t Ret = 0;
for (auto &Client : Clients)
@@ -684,7 +617,7 @@ int32_t RemoteClientManager::getNumberOfDevices() {
std::pair<int32_t, int32_t> RemoteClientManager::mapDeviceId(int32_t DeviceId) {
for (size_t ClientIdx = 0; ClientIdx < Devices.size(); ClientIdx++) {
- if (!(DeviceId >= Devices[ClientIdx]))
+ if (DeviceId < Devices[ClientIdx])
return {ClientIdx, DeviceId};
DeviceId -= Devices[ClientIdx];
}
@@ -711,13 +644,6 @@ __tgt_target_table *RemoteClientManager::loadBinary(int32_t DeviceId,
return Clients[ClientIdx].loadBinary(DeviceIdx, Image);
}
-int64_t RemoteClientManager::synchronize(int32_t DeviceId,
- __tgt_async_info *AsyncInfo) {
- int32_t ClientIdx, DeviceIdx;
- std::tie(ClientIdx, DeviceIdx) = mapDeviceId(DeviceId);
- return Clients[ClientIdx].synchronize(DeviceIdx, AsyncInfo);
-}
-
int32_t RemoteClientManager::isDataExchangeable(int32_t SrcDevId,
int32_t DstDevId) {
int32_t SrcClientIdx, SrcDeviceIdx, DstClientIdx, DstDeviceIdx;
@@ -739,51 +665,47 @@ int32_t RemoteClientManager::dataDelete(int32_t DeviceId, void *TgtPtr) {
return Clients[ClientIdx].dataDelete(DeviceIdx, TgtPtr);
}
-int32_t RemoteClientManager::dataSubmitAsync(int32_t DeviceId, void *TgtPtr,
- void *HstPtr, int64_t Size,
- __tgt_async_info *AsyncInfo) {
+int32_t RemoteClientManager::dataSubmit(int32_t DeviceId, void *TgtPtr,
+ void *HstPtr, int64_t Size) {
int32_t ClientIdx, DeviceIdx;
std::tie(ClientIdx, DeviceIdx) = mapDeviceId(DeviceId);
- return Clients[ClientIdx].dataSubmitAsync(DeviceIdx, TgtPtr, HstPtr, Size,
- AsyncInfo);
+ return Clients[ClientIdx].dataSubmit(DeviceIdx, TgtPtr, HstPtr, Size);
}
-int32_t RemoteClientManager::dataRetrieveAsync(int32_t DeviceId, void *HstPtr,
- void *TgtPtr, int64_t Size,
- __tgt_async_info *AsyncInfo) {
+int32_t RemoteClientManager::dataRetrieve(int32_t DeviceId, void *HstPtr,
+ void *TgtPtr, int64_t Size) {
int32_t ClientIdx, DeviceIdx;
std::tie(ClientIdx, DeviceIdx) = mapDeviceId(DeviceId);
- return Clients[ClientIdx].dataRetrieveAsync(DeviceIdx, HstPtr, TgtPtr, Size,
- AsyncInfo);
+ return Clients[ClientIdx].dataRetrieve(DeviceIdx, HstPtr, TgtPtr, Size);
}
-int32_t RemoteClientManager::dataExchangeAsync(int32_t SrcDevId, void *SrcPtr,
- int32_t DstDevId, void *DstPtr,
- int64_t Size,
- __tgt_async_info *AsyncInfo) {
+int32_t RemoteClientManager::dataExchange(int32_t SrcDevId, void *SrcPtr,
+ int32_t DstDevId, void *DstPtr,
+ int64_t Size) {
int32_t SrcClientIdx, SrcDeviceIdx, DstClientIdx, DstDeviceIdx;
std::tie(SrcClientIdx, SrcDeviceIdx) = mapDeviceId(SrcDevId);
std::tie(DstClientIdx, DstDeviceIdx) = mapDeviceId(DstDevId);
- return Clients[SrcClientIdx].dataExchangeAsync(
- SrcDeviceIdx, SrcPtr, DstDeviceIdx, DstPtr, Size, AsyncInfo);
+ return Clients[SrcClientIdx].dataExchange(SrcDeviceIdx, SrcPtr, DstDeviceIdx,
+ DstPtr, Size);
}
-int32_t RemoteClientManager::runTargetRegionAsync(
- int32_t DeviceId, void *TgtEntryPtr, void **TgtArgs, ptr
diff _t *TgtOffsets,
- int32_t ArgNum, __tgt_async_info *AsyncInfo) {
+int32_t RemoteClientManager::runTargetRegion(int32_t DeviceId,
+ void *TgtEntryPtr, void **TgtArgs,
+ ptr
diff _t *TgtOffsets,
+ int32_t ArgNum) {
int32_t ClientIdx, DeviceIdx;
std::tie(ClientIdx, DeviceIdx) = mapDeviceId(DeviceId);
- return Clients[ClientIdx].runTargetRegionAsync(
- DeviceIdx, TgtEntryPtr, TgtArgs, TgtOffsets, ArgNum, AsyncInfo);
+ return Clients[ClientIdx].runTargetRegion(DeviceIdx, TgtEntryPtr, TgtArgs,
+ TgtOffsets, ArgNum);
}
-int32_t RemoteClientManager::runTargetTeamRegionAsync(
+int32_t RemoteClientManager::runTargetTeamRegion(
int32_t DeviceId, void *TgtEntryPtr, void **TgtArgs, ptr
diff _t *TgtOffsets,
int32_t ArgNum, int32_t TeamNum, int32_t ThreadLimit,
- uint64_t LoopTripCount, __tgt_async_info *AsyncInfo) {
+ uint64_t LoopTripCount) {
int32_t ClientIdx, DeviceIdx;
std::tie(ClientIdx, DeviceIdx) = mapDeviceId(DeviceId);
- return Clients[ClientIdx].runTargetTeamRegionAsync(
- DeviceIdx, TgtEntryPtr, TgtArgs, TgtOffsets, ArgNum, TeamNum, ThreadLimit,
- LoopTripCount, AsyncInfo);
+ return Clients[ClientIdx].runTargetTeamRegion(DeviceIdx, TgtEntryPtr, TgtArgs,
+ TgtOffsets, ArgNum, TeamNum,
+ ThreadLimit, LoopTripCount);
}
diff --git a/openmp/libomptarget/plugins/remote/src/Client.h b/openmp/libomptarget/plugins/remote/src/Client.h
index e29d6eb1c6a6b..5f4006926e934 100644
--- a/openmp/libomptarget/plugins/remote/src/Client.h
+++ b/openmp/libomptarget/plugins/remote/src/Client.h
@@ -30,11 +30,10 @@ using namespace RemoteOffloading;
using namespace google;
class RemoteOffloadClient {
- const int Timeout;
-
int DebugLevel;
- uint64_t MaxSize;
- int64_t BlockSize;
+ const int Timeout;
+ const uint64_t MaxSize;
+ const int64_t BlockSize;
std::unique_ptr<RemoteOffload::Stub> Stub;
std::unique_ptr<protobuf::Arena> Arena;
@@ -45,8 +44,8 @@ class RemoteOffloadClient {
std::map<int32_t, std::unique_ptr<__tgt_target_table>> DevicesToTables;
template <typename Fn1, typename Fn2, typename TReturn>
- auto remoteCall(Fn1 Preprocess, Fn2 Postprocess, TReturn ErrorValue,
- bool Timeout = true);
+ auto remoteCall(Fn1 Preprocessor, Fn2 Postprocessor, TReturn ErrorValue,
+ bool CanTimeOut = true);
public:
RemoteOffloadClient(std::shared_ptr<Channel> Channel, int Timeout,
@@ -77,35 +76,29 @@ class RemoteOffloadClient {
int32_t initRequires(int64_t RequiresFlags);
__tgt_target_table *loadBinary(int32_t DeviceId, __tgt_device_image *Image);
- int64_t synchronize(int32_t DeviceId, __tgt_async_info *AsyncInfo);
- int32_t isDataExchangeable(int32_t SrcDevId, int32_t DstDevId);
void *dataAlloc(int32_t DeviceId, int64_t Size, void *HstPtr);
int32_t dataDelete(int32_t DeviceId, void *TgtPtr);
- int32_t dataSubmitAsync(int32_t DeviceId, void *TgtPtr, void *HstPtr,
- int64_t Size, __tgt_async_info *AsyncInfo);
- int32_t dataRetrieveAsync(int32_t DeviceId, void *HstPtr, void *TgtPtr,
- int64_t Size, __tgt_async_info *AsyncInfo);
+ int32_t dataSubmit(int32_t DeviceId, void *TgtPtr, void *HstPtr,
+ int64_t Size);
+ int32_t dataRetrieve(int32_t DeviceId, void *HstPtr, void *TgtPtr,
+ int64_t Size);
- int32_t dataExchangeAsync(int32_t SrcDevId, void *SrcPtr, int32_t DstDevId,
- void *DstPtr, int64_t Size,
- __tgt_async_info *AsyncInfo);
-
- int32_t runTargetRegionAsync(int32_t DeviceId, void *TgtEntryPtr,
- void **TgtArgs, ptr
diff _t *TgtOffsets,
- int32_t ArgNum, __tgt_async_info *AsyncInfo);
-
- int32_t runTargetTeamRegionAsync(int32_t DeviceId, void *TgtEntryPtr,
- void **TgtArgs, ptr
diff _t *TgtOffsets,
- int32_t ArgNum, int32_t TeamNum,
- int32_t ThreadLimit, uint64_t LoopTripCount,
- __tgt_async_info *AsyncInfo);
+ int32_t isDataExchangeable(int32_t SrcDevId, int32_t DstDevId);
+ int32_t dataExchange(int32_t SrcDevId, void *SrcPtr, int32_t DstDevId,
+ void *DstPtr, int64_t Size);
+
+ int32_t runTargetRegion(int32_t DeviceId, void *TgtEntryPtr, void **TgtArgs,
+ ptr
diff _t *TgtOffsets, int32_t ArgNum);
+ int32_t runTargetTeamRegion(int32_t DeviceId, void *TgtEntryPtr,
+ void **TgtArgs, ptr
diff _t *TgtOffsets,
+ int32_t ArgNum, int32_t TeamNum,
+ int32_t ThreadLimit, uint64_t LoopTripCount);
};
class RemoteClientManager {
private:
- std::vector<std::string> Addresses;
std::vector<RemoteOffloadClient> Clients;
std::vector<int> Devices;
@@ -113,16 +106,16 @@ class RemoteClientManager {
int DebugLevel;
public:
- RemoteClientManager(std::vector<std::string> Addresses, int Timeout,
- uint64_t MaxSize, int64_t BlockSize)
- : Addresses(Addresses) {
+ RemoteClientManager() {
+ ClientManagerConfigTy Config;
+
grpc::ChannelArguments ChArgs;
ChArgs.SetMaxReceiveMessageSize(-1);
DebugLevel = getDebugLevel();
- for (auto Address : Addresses) {
+ for (auto Address : Config.ServerAddresses) {
Clients.push_back(RemoteOffloadClient(
grpc::CreateChannel(Address, grpc::InsecureChannelCredentials()),
- Timeout, MaxSize, BlockSize));
+ Config.Timeout, Config.MaxSize, Config.BlockSize));
}
}
@@ -138,30 +131,25 @@ class RemoteClientManager {
int32_t initRequires(int64_t RequiresFlags);
__tgt_target_table *loadBinary(int32_t DeviceId, __tgt_device_image *Image);
- int64_t synchronize(int32_t DeviceId, __tgt_async_info *AsyncInfo);
- int32_t isDataExchangeable(int32_t SrcDevId, int32_t DstDevId);
void *dataAlloc(int32_t DeviceId, int64_t Size, void *HstPtr);
int32_t dataDelete(int32_t DeviceId, void *TgtPtr);
- int32_t dataSubmitAsync(int32_t DeviceId, void *TgtPtr, void *HstPtr,
- int64_t Size, __tgt_async_info *AsyncInfo);
- int32_t dataRetrieveAsync(int32_t DeviceId, void *HstPtr, void *TgtPtr,
- int64_t Size, __tgt_async_info *AsyncInfo);
+ int32_t dataSubmit(int32_t DeviceId, void *TgtPtr, void *HstPtr,
+ int64_t Size);
+ int32_t dataRetrieve(int32_t DeviceId, void *HstPtr, void *TgtPtr,
+ int64_t Size);
- int32_t dataExchangeAsync(int32_t SrcDevId, void *SrcPtr, int32_t DstDevId,
- void *DstPtr, int64_t Size,
- __tgt_async_info *AsyncInfo);
-
- int32_t runTargetRegionAsync(int32_t DeviceId, void *TgtEntryPtr,
- void **TgtArgs, ptr
diff _t *TgtOffsets,
- int32_t ArgNum, __tgt_async_info *AsyncInfo);
-
- int32_t runTargetTeamRegionAsync(int32_t DeviceId, void *TgtEntryPtr,
- void **TgtArgs, ptr
diff _t *TgtOffsets,
- int32_t ArgNum, int32_t TeamNum,
- int32_t ThreadLimit, uint64_t LoopTripCount,
- __tgt_async_info *AsyncInfo);
+ int32_t isDataExchangeable(int32_t SrcDevId, int32_t DstDevId);
+ int32_t dataExchange(int32_t SrcDevId, void *SrcPtr, int32_t DstDevId,
+ void *DstPtr, int64_t Size);
+
+ int32_t runTargetRegion(int32_t DeviceId, void *TgtEntryPtr, void **TgtArgs,
+ ptr
diff _t *TgtOffsets, int32_t ArgNum);
+ int32_t runTargetTeamRegion(int32_t DeviceId, void *TgtEntryPtr,
+ void **TgtArgs, ptr
diff _t *TgtOffsets,
+ int32_t ArgNum, int32_t TeamNum,
+ int32_t ThreadLimit, uint64_t LoopTripCount);
};
#endif
diff --git a/openmp/libomptarget/plugins/remote/src/rtl.cpp b/openmp/libomptarget/plugins/remote/src/rtl.cpp
index 26f172a1fdcf7..e80f55c6245b7 100644
--- a/openmp/libomptarget/plugins/remote/src/rtl.cpp
+++ b/openmp/libomptarget/plugins/remote/src/rtl.cpp
@@ -27,15 +27,7 @@ RemoteClientManager *Manager;
__attribute__((constructor(101))) void initRPC() {
DP("Init RPC library!\n");
- RPCConfig Config;
- parseEnvironment(Config);
-
- int Timeout = 5;
- if (const char *Env1 = std::getenv("LIBOMPTARGET_RPC_LATENCY"))
- Timeout = std::stoi(Env1);
-
- Manager = new RemoteClientManager(Config.ServerAddresses, Timeout,
- Config.MaxSize, Config.BlockSize);
+ Manager = new RemoteClientManager();
}
__attribute__((destructor(101))) void deinitRPC() {
@@ -76,17 +68,13 @@ __tgt_target_table *__tgt_rtl_load_binary(int32_t DeviceId,
return Manager->loadBinary(DeviceId, (__tgt_device_image *)Image);
}
-int32_t __tgt_rtl_synchronize(int32_t DeviceId, __tgt_async_info *AsyncInfo) {
- return Manager->synchronize(DeviceId, AsyncInfo);
-}
-
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) {
+ int32_t Kind) {
+ if (Kind != TARGET_ALLOC_DEFAULT) {
REPORT("Invalid target data allocation kind or requested allocator not "
"implemented yet\n");
return NULL;
@@ -97,24 +85,12 @@ void *__tgt_rtl_data_alloc(int32_t DeviceId, int64_t Size, void *HstPtr,
int32_t __tgt_rtl_data_submit(int32_t DeviceId, void *TgtPtr, void *HstPtr,
int64_t Size) {
- return Manager->dataSubmitAsync(DeviceId, TgtPtr, HstPtr, Size, nullptr);
-}
-
-int32_t __tgt_rtl_data_submit_async(int32_t DeviceId, void *TgtPtr,
- void *HstPtr, int64_t Size,
- __tgt_async_info *AsyncInfo) {
- return Manager->dataSubmitAsync(DeviceId, TgtPtr, HstPtr, Size, AsyncInfo);
+ 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->dataRetrieveAsync(DeviceId, HstPtr, TgtPtr, Size, nullptr);
-}
-
-int32_t __tgt_rtl_data_retrieve_async(int32_t DeviceId, void *HstPtr,
- void *TgtPtr, int64_t Size,
- __tgt_async_info *AsyncInfo) {
- return Manager->dataRetrieveAsync(DeviceId, HstPtr, TgtPtr, Size, AsyncInfo);
+ return Manager->dataRetrieve(DeviceId, HstPtr, TgtPtr, Size);
}
int32_t __tgt_rtl_data_delete(int32_t DeviceId, void *TgtPtr) {
@@ -123,31 +99,15 @@ int32_t __tgt_rtl_data_delete(int32_t DeviceId, void *TgtPtr) {
int32_t __tgt_rtl_data_exchange(int32_t SrcDevId, void *SrcPtr,
int32_t DstDevId, void *DstPtr, int64_t Size) {
- return Manager->dataExchangeAsync(SrcDevId, SrcPtr, DstDevId, DstPtr, Size,
- nullptr);
+ return Manager->dataExchange(SrcDevId, SrcPtr, DstDevId, DstPtr, Size);
}
-int32_t __tgt_rtl_data_exchange_async(int32_t SrcDevId, void *SrcPtr,
- int32_t DstDevId, void *DstPtr,
- int64_t Size,
- __tgt_async_info *AsyncInfo) {
- return Manager->dataExchangeAsync(SrcDevId, SrcPtr, DstDevId, DstPtr, Size,
- AsyncInfo);
-}
int32_t __tgt_rtl_run_target_region(int32_t DeviceId, void *TgtEntryPtr,
void **TgtArgs, ptr
diff _t *TgtOffsets,
int32_t ArgNum) {
- return Manager->runTargetRegionAsync(DeviceId, TgtEntryPtr, TgtArgs,
- TgtOffsets, ArgNum, nullptr);
-}
-
-int32_t __tgt_rtl_run_target_region_async(int32_t DeviceId, void *TgtEntryPtr,
- void **TgtArgs, ptr
diff _t *TgtOffsets,
- int32_t ArgNum,
- __tgt_async_info *AsyncInfo) {
- return Manager->runTargetRegionAsync(DeviceId, TgtEntryPtr, TgtArgs,
- TgtOffsets, ArgNum, AsyncInfo);
+ return Manager->runTargetRegion(DeviceId, TgtEntryPtr, TgtArgs, TgtOffsets,
+ ArgNum);
}
int32_t __tgt_rtl_run_target_team_region(int32_t DeviceId, void *TgtEntryPtr,
@@ -155,18 +115,9 @@ int32_t __tgt_rtl_run_target_team_region(int32_t DeviceId, void *TgtEntryPtr,
int32_t ArgNum, int32_t TeamNum,
int32_t ThreadLimit,
uint64_t LoopTripCount) {
- return Manager->runTargetTeamRegionAsync(DeviceId, TgtEntryPtr, TgtArgs,
- TgtOffsets, ArgNum, TeamNum,
- ThreadLimit, LoopTripCount, nullptr);
-}
-
-int32_t __tgt_rtl_run_target_team_region_async(
- int32_t DeviceId, void *TgtEntryPtr, void **TgtArgs, ptr
diff _t *TgtOffsets,
- int32_t ArgNum, int32_t TeamNum, int32_t ThreadLimit,
- uint64_t LoopTripCount, __tgt_async_info *AsyncInfo) {
- return Manager->runTargetTeamRegionAsync(
- DeviceId, TgtEntryPtr, TgtArgs, TgtOffsets, ArgNum, TeamNum, ThreadLimit,
- LoopTripCount, AsyncInfo);
+ return Manager->runTargetTeamRegion(DeviceId, TgtEntryPtr, TgtArgs,
+ TgtOffsets, ArgNum, TeamNum, ThreadLimit,
+ LoopTripCount);
}
// Exposed library API function
More information about the Openmp-commits
mailing list