[Libomptarget][remote] Fix compile-time error

[atmnpatel]

Summary

This fixes a compile-time error recently introduced within the remote
offloading plugin. This patch also removes some extra linker flags that are unnecessary, and adds an explicit abseil linker flag without which we occasionally get problems.

[atmnpatel]

Ran clang format.

[jdoerfert]

LG

openmp/libomptarget/plugins/remote/server/CMakeLists.txt

add_executable(openmp-offloading-server
         ${RPC_SRC_DIR}/Utils.cpp
         Server.cpp
         OffloadingServer.cpp
 )
 
 target_link_libraries(openmp-offloading-server
         grpc++
         protobuf
+        absl::synchronization
         ${OPENMP_PTHREAD_LIB}
-        "-ldl" "-lomp" "-fopenmp" "-Wl,--version-script=${CMAKE_CURRENT_SOURCE_DIR}/../../exports")
+        "-Wl,--version-script=${CMAKE_CURRENT_SOURCE_DIR}/../../exports")

openmp/libomptarget/plugins/remote/server/Server.cpp

Status RemoteOffloadImpl::GetNumberOfDevices(ServerContext *Context,
   NumberOfDevices->set_number(Devices);
 
   SERVER_DBG("Got number of devices")
   return Status::OK;
 }
 
 Status RemoteOffloadImpl::InitDevice(ServerContext *Context,
                                      const I32 *DeviceNum, I32 *Reply) {
-  Reply->set_number(PM->Devices[DeviceNum->number()].RTL->init_device(
+  Reply->set_number(PM->Devices[DeviceNum->number()]->RTL->init_device(
       mapHostRTLDeviceId(DeviceNum->number())));
 
   SERVER_DBG("Initialized device %d", DeviceNum->number())
   return Status::OK;
 }
 
 Status RemoteOffloadImpl::InitRequires(ServerContext *Context,
                                        const I64 *RequiresFlag, I32 *Reply) {
   for (auto &Device : PM->Devices)
-    if (Device.RTL->init_requires)
-      Device.RTL->init_requires(RequiresFlag->number());
+    if (Device->RTL->init_requires)
+      Device->RTL->init_requires(RequiresFlag->number());
   Reply->set_number(RequiresFlag->number());
 
   SERVER_DBG("Initialized requires for devices")
   return Status::OK;
 }
 
 Status RemoteOffloadImpl::LoadBinary(ServerContext *Context,
                                      const Binary *Binary, TargetTable *Reply) {
   __tgt_device_image *Image =
       HostToRemoteDeviceImage[(void *)Binary->image_ptr()];
 
-  Table = PM->Devices[Binary->device_id()].RTL->load_binary(
+  Table = PM->Devices[Binary->device_id()]->RTL->load_binary(
       mapHostRTLDeviceId(Binary->device_id()), Image);
   if (Table)
     loadTargetTable(Table, *Reply, Image);
 
   SERVER_DBG("Loaded binary (%p) to device %d", (void *)Binary->image_ptr(),
              Binary->device_id())
   return Status::OK;
 }
 
 Status RemoteOffloadImpl::IsDataExchangeable(ServerContext *Context,
                                              const DevicePair *Request,
                                              I32 *Reply) {
   Reply->set_number(-1);
   if (PM->Devices[mapHostRTLDeviceId(Request->src_dev_id())]
-          .RTL->is_data_exchangable)
+          ->RTL->is_data_exchangable)
     Reply->set_number(PM->Devices[mapHostRTLDeviceId(Request->src_dev_id())]
-                          .RTL->is_data_exchangable(Request->src_dev_id(),
+                          ->RTL->is_data_exchangable(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) {
-  uint64_t TgtPtr = (uint64_t)PM->Devices[Request->device_id()].RTL->data_alloc(
+  uint64_t TgtPtr =
+      (uint64_t)PM->Devices[Request->device_id()]->RTL->data_alloc(
           mapHostRTLDeviceId(Request->device_id()), Request->size(),
           (void *)Request->hst_ptr(), TARGET_ALLOC_DEFAULT);
   Reply->set_number(TgtPtr);
 
   SERVER_DBG("Allocated at " DPxMOD "", DPxPTR((void *)TgtPtr))
 
   return Status::OK;
 }
 
 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()) {
       Reader->SendInitialMetadata();
 
-      Reply->set_number(PM->Devices[Request.device_id()].RTL->data_submit(
+      Reply->set_number(PM->Devices[Request.device_id()]->RTL->data_submit(
           mapHostRTLDeviceId(Request.device_id()), (void *)Request.tgt_ptr(),
           (void *)Request.data().data(), Request.data().size()));
 
       SERVER_DBG("Submitted %lu bytes async to (%p) on device %d",
                  Request.data().size(), (void *)Request.tgt_ptr(),
                  Request.device_id())
 
       return Status::OK;
     }
     if (!HostCopy) {
       HostCopy = new uint8_t[Request.size()];
       Reader->SendInitialMetadata();
     }
 
     memcpy((void *)((char *)HostCopy + Request.start()), Request.data().data(),
            Request.data().size());
   }
 
-  Reply->set_number(PM->Devices[Request.device_id()].RTL->data_submit(
+  Reply->set_number(PM->Devices[Request.device_id()]->RTL->data_submit(
       mapHostRTLDeviceId(Request.device_id()), (void *)Request.tgt_ptr(),
       HostCopy, Request.size()));
 
   delete[] HostCopy;
 
   SERVER_DBG("Submitted %lu bytes to (%p) on device %d", Request.data().size(),
              (void *)Request.tgt_ptr(), Request.device_id())
 
   return Status::OK;
 }
 
 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(
+  auto Ret = PM->Devices[Request->device_id()]->RTL->data_retrieve(
       mapHostRTLDeviceId(Request->device_id()), HstPtr.get(),
       (void *)Request->tgt_ptr(), Request->size());
 
   if (Arena->SpaceAllocated() >= MaxSize)
     Arena->Reset();
 
   if (Request->size() > BlockSize) {
     uint64_t Start = 0, End = BlockSize;
Status RemoteOffloadImpl::DataRetrieve(ServerContext *Context,
   }
 
   return Status::OK;
 }
 
 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(
+  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(),
         mapHostRTLDeviceId(Request->dst_dev_id()), (void *)Request->dst_ptr(),
         Request->size());
     Reply->set_number(Ret);
   } else
     Reply->set_number(-1);
 
   SERVER_DBG(
       "Exchanged 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())
   return Status::OK;
 }
 
 Status RemoteOffloadImpl::DataDelete(ServerContext *Context,
                                      const DeleteData *Request, I32 *Reply) {
-  auto Ret = PM->Devices[Request->device_id()].RTL->data_delete(
+  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()))
   return Status::OK;
 }
 
 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];
 
   std::vector<ptrdiff_t> TgtOffsets(Request->arg_num());
   const auto *TgtOffsetItr = Request->tgt_offsets().begin();
   for (auto I = 0; I < Request->arg_num(); I++, TgtOffsetItr++)
     TgtOffsets[I] = (ptrdiff_t)*TgtOffsetItr;
 
   void *TgtEntryPtr = ((__tgt_offload_entry *)Request->tgt_entry_ptr())->addr;
 
-  int32_t Ret = PM->Devices[Request->device_id()].RTL->run_region(
+  int32_t Ret = PM->Devices[Request->device_id()]->RTL->run_region(
       mapHostRTLDeviceId(Request->device_id()), TgtEntryPtr,
       (void **)TgtArgs.data(), TgtOffsets.data(), Request->arg_num());
 
   Reply->set_number(Ret);
 
   SERVER_DBG("Ran TargetRegion on device %d with %d args",
              mapHostRTLDeviceId(Request->device_id()), Request->arg_num())
   return Status::OK;
 }
 
 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];
 
   std::vector<ptrdiff_t> TgtOffsets(Request->arg_num());
   const auto *TgtOffsetItr = Request->tgt_offsets().begin();
   for (auto I = 0; I < Request->arg_num(); I++, TgtOffsetItr++)
     TgtOffsets[I] = (ptrdiff_t)*TgtOffsetItr;
 
   void *TgtEntryPtr = ((__tgt_offload_entry *)Request->tgt_entry_ptr())->addr;
 
-  int32_t Ret = PM->Devices[Request->device_id()].RTL->run_team_region(
+  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(),
       Request->team_num(), Request->thread_limit(), Request->loop_tripcount());
 
   Reply->set_number(Ret);
 
   SERVER_DBG("Ran TargetTeamRegion on device %d with %d args",
              mapHostRTLDeviceId(Request->device_id()), Request->arg_num())

openmp/libomptarget/plugins/remote/src/CMakeLists.txt

 )
 
 # Install plugin under the lib destination folder.
 install(TARGETS omptarget.rtl.rpc LIBRARY DESTINATION "${OPENMP_INSTALL_LIBDIR}")
 
 target_link_libraries(omptarget.rtl.rpc
   grpc++
   protobuf
-  "-ldl"
+  absl::synchronization
   ${OPENMP_PTHREAD_LIB}
   "-Wl,--version-script=${CMAKE_CURRENT_SOURCE_DIR}/../../exports")
 
 # Report to the parent scope that we are building a plugin for RPC.
 set(LIBOMPTARGET_SYSTEM_TARGETS "${LIBOMPTARGET_SYSTEM_TARGETS} rpc" PARENT_SCOPE)