SWDEV-241902 - Changes to pass file descriptor and offset to load code object.

Change-Id: I96add27f4fde1b5ee5501e206b7e85ab77e87dfc [ROCm/hip commit: 89e5e8b90c]
2020-08-03 11:23:33 -04:00
parent 2bdb08bbe7
commit ec47e5a7d4
9 changed files with 371 additions and 219 deletions
@@ -0,0 +1,158 @@
+#include "hip_fatbin.hpp"
+
+#include "hip_code_object.hpp"
+
+namespace hip {
+
+FatBinaryDeviceInfo::~FatBinaryDeviceInfo() {
+  if (program_ != nullptr) {
+    program_->release();
+    program_ = nullptr;
+  }
+}
+
+FatBinaryInfo::FatBinaryInfo(const char* fname, const void* image)
+               : fdesc_(-1), fsize_(0), image_(image), uri_(std::string()) {
+  guarantee(fname || image);
+
+  if (fname != nullptr) {
+    fname_ = std::string(fname);
+  } else {
+    fname_ = std::string();
+  }
+
+  fatbin_dev_info_.resize(g_devices.size());
+}
+
+FatBinaryInfo::~FatBinaryInfo() {
+
+  for (auto& fbd: fatbin_dev_info_) {
+    delete fbd;
+  }
+
+  if (fdesc_ > 0) {
+    if (!amd::Os::CloseFileHandle(fdesc_)) {
+      guarantee(false && "Cannot close file");
+    }
+
+    if (!amd::Os::MemoryUnmapFile(image_, fsize_)) {
+      guarantee(false && "Cannot unmap file");
+    }
+  }
+
+  fname_ = std::string();
+  fdesc_ = -1;
+  fsize_ = 0;
+  image_ = nullptr;
+  uri_ = std::string();
+}
+
+hipError_t FatBinaryInfo::ExtractFatBinary(const std::vector<hip::Device*>& devices) {
+  hipError_t hip_error = hipSuccess;
+  std::vector<std::pair<const void*, size_t>> code_objs;
+  code_objs.resize(devices.size());
+
+  // Copy device names for Extract Code object File
+  std::vector<const char*> device_names;
+  for (size_t dev_idx = 0; dev_idx < devices.size(); ++dev_idx) {
+    device_names.push_back(devices[dev_idx]->devices()[0]->info().name_);
+  }
+
+  // We are given file name, get the file desc and file size
+  if (fname_.size() > 0) {
+    // Get File Handle & size of the file.
+    if (!amd::Os::GetFileHandle(fname_.c_str(), &fdesc_, &fsize_)) {
+      return hipErrorFileNotFound;
+    }
+
+    // Extract the code object from file
+    hip_error = CodeObject::ExtractCodeObjectFromFile(fdesc_, fsize_,
+                device_names, code_objs);
+
+    // Map the file memory, Later: only map offset, throws error in ElfMagic now.
+    if (!amd::Os::MemoryMapFileDesc(fdesc_, fsize_, 0, &image_)) {
+      return hipErrorInvalidValue;
+    }
+
+  } else if (image_ != nullptr) {
+    // We are directly given image pointer directly, try to extract file desc & file Size
+    hip_error = CodeObject::ExtractCodeObjectFromMemory(image_,
+                device_names, code_objs, uri_);
+  } else {
+    return hipErrorMissingConfiguration;
+  }
+
+  if (hip_error == hipErrorNoBinaryForGpu) {
+    guarantee(false && "hipErrorNoBinaryForGpu: Coudn't find binary for current devices!");
+    return hip_error;
+  }
+
+  if (hip_error == hipErrorInvalidKernelFile) {
+    for (size_t dev_idx = 0; dev_idx < devices.size(); ++dev_idx) {
+      // the image type is no CLANG_OFFLOAD_BUNDLER, image for current device directly passed
+      fatbin_dev_info_[devices[dev_idx]->deviceId()]
+        = new FatBinaryDeviceInfo(image_, CodeObject::ElfSize(image_), 0);
+    }
+  } else if(hip_error == hipSuccess) {
+    for (size_t dev_idx = 0; dev_idx < devices.size(); ++dev_idx) {
+      // Calculate the offset wrt binary_image and the original image
+      size_t offset_l
+        = (reinterpret_cast<address>(const_cast<void*>(code_objs[dev_idx].first))
+            - reinterpret_cast<address>(const_cast<void*>(image_)));
+
+      fatbin_dev_info_[devices[dev_idx]->deviceId()]
+        = new FatBinaryDeviceInfo(code_objs[dev_idx].first, code_objs[dev_idx].second, offset_l);
+    }
+  }
+
+  for (size_t dev_idx = 0; dev_idx < devices.size(); ++dev_idx) {
+    fatbin_dev_info_[devices[dev_idx]->deviceId()]->program_
+       = new amd::Program(*devices[dev_idx]->asContext());
+    if (fatbin_dev_info_[devices[dev_idx]->deviceId()]->program_ == NULL) {
+      return hipErrorOutOfMemory;
+    }
+  }
+
+  return hipSuccess;
+}
+
+hipError_t FatBinaryInfo::AddDevProgram(const int device_id) {
+  // Device Id bounds Check
+  DeviceIdCheck(device_id);
+
+  FatBinaryDeviceInfo* fbd_info = fatbin_dev_info_[device_id];
+  // If fat binary was already added, skip this step and return success
+  if (fbd_info->add_dev_prog_ == false) {
+    amd::Context* ctx = g_devices[device_id]->asContext();
+    if (CL_SUCCESS != fbd_info->program_->addDeviceProgram(*ctx->devices()[0],
+                                          fbd_info->binary_image_,
+                                          fbd_info->binary_size_, false,
+                                          nullptr, nullptr, fdesc_,
+                                          fbd_info->binary_offset_, uri_)) {
+      return hipErrorInvalidKernelFile;
+    }
+    fbd_info->add_dev_prog_ = true;
+  }
+  return hipSuccess;
+}
+
+hipError_t FatBinaryInfo::BuildProgram(const int device_id) {
+
+  // Device Id Check and Add DeviceProgram if not added so far
+  DeviceIdCheck(device_id);
+  IHIP_RETURN_ONFAIL(AddDevProgram(device_id));
+
+  // If Program was already built skip this step and return success
+  FatBinaryDeviceInfo* fbd_info = fatbin_dev_info_[device_id];
+  if (fbd_info->prog_built_ == false) {
+    if(CL_SUCCESS != fbd_info->program_->build(g_devices[device_id]->devices(),
+                                               nullptr, nullptr, nullptr,
+                                               kOptionChangeable, kNewDevProg)) {
+      return hipErrorSharedObjectInitFailed;
+    }
+    fbd_info->prog_built_ = true;
+  }
+  return hipSuccess;
+}
+
+} //namespace : hip