P4 to Git Change 1972494 by kjayapra@0_HIPWS_P2P1_ROCM on 2019/07/23 20:01:13

SWDEV-144570 - Handling variable register during hipModuleLoad.

Affected files ...

... //depot/stg/opencl/drivers/opencl/api/hip/hip_internal.hpp#31 edit
... //depot/stg/opencl/drivers/opencl/api/hip/hip_module.cpp#30 edit
... //depot/stg/opencl/drivers/opencl/api/hip/hip_platform.cpp#34 edit
... //depot/stg/opencl/drivers/opencl/runtime/device/devprogram.cpp#51 edit
... //depot/stg/opencl/drivers/opencl/runtime/device/devprogram.hpp#30 edit


[ROCm/hip commit: c837c6e769]

projects/hip/api/hip/hip_internal.hpp

@@ -125,7 +125,7 @@ public:
   };
 private:
   std::unordered_map<const void*, DeviceFunction > functions_;
-  std::unordered_map<const void*, DeviceVar > vars_;
+  std::unordered_map<std::string, DeviceVar > vars_;
 
   static PlatformState* platform_;
 
@@ -136,6 +136,8 @@ public:
     return *platform_;
   }
 
+  void unregisterVar(hipModule_t hmod);
+
   void registerVar(const void* hostvar, const DeviceVar& var);
   void registerFunction(const void* hostFunction, const DeviceFunction& func);
 

projects/hip/api/hip/hip_module.cpp

@@ -70,6 +70,10 @@ hipError_t hipModuleLoad(hipModule_t *module, const char *fname)
   HIP_RETURN(ihipModuleLoadData(module, tmp.data()));
 }
 
+bool ihipModuleUnregisterGlobal(hipModule_t hmod) {
+  PlatformState::instance().unregisterVar(hmod);
+  return true;
+}
 
 hipError_t hipModuleUnload(hipModule_t hmod)
 {
@@ -81,6 +85,10 @@ hipError_t hipModuleUnload(hipModule_t hmod)
 
   amd::Program* program = as_amd(reinterpret_cast<cl_program>(hmod));
 
+  if(!ihipModuleUnregisterGlobal(hmod)) {
+    HIP_RETURN(hipErrorUnknown);
+  }
+
   program->release();
 
   HIP_RETURN(hipSuccess);
@@ -97,6 +105,33 @@ extern bool __hipExtractCodeObjectFromFatBinary(const void* data,
                                                 const std::vector<const char*>& devices,
                                                 std::vector<std::pair<const void*, size_t>>& code_objs);
 
+bool ihipModuleRegisterGlobal(amd::Program* program, hipModule_t* module) {
+
+  size_t var_size = 0;
+  hipDeviceptr_t device_ptr = nullptr;
+  std::vector<std::string> var_names;
+
+  device::Program* dev_program
+    = program->getDeviceProgram(*hip::getCurrentContext()->devices()[0]);
+
+  if (!dev_program->getGlobalSymbolsFromCodeObj(&var_names)) {
+    return false;
+  }
+
+  for (auto it = var_names.begin(); it != var_names.end(); ++it) {
+    auto modules = new std::vector<std::pair<hipModule_t, bool> >{g_devices.size()};
+    for (size_t dev = 0; dev < g_devices.size(); ++dev) {
+      modules->at(dev) = std::make_pair(*module, false);
+    }
+
+    PlatformState::DeviceVar dvar{it->c_str(), modules,
+      std::vector<PlatformState::RegisteredVar>{ g_devices.size()}};
+    PlatformState::instance().registerVar(it->c_str(), dvar);
+  }
+
+  return true;
+}
+
 hipError_t ihipModuleLoadData(hipModule_t *module, const void *image)
 {
   std::vector<std::pair<const void*, size_t>> code_objs;
@@ -115,6 +150,10 @@ hipError_t ihipModuleLoadData(hipModule_t *module, const void *image)
 
   *module = reinterpret_cast<hipModule_t>(as_cl(program));
 
+  if (!ihipModuleRegisterGlobal(program, module)) {
+    return hipErrorUnknown;
+  }
+
   return hipSuccess;
 }
 

projects/hip/api/hip/hip_platform.cpp

@@ -165,10 +165,23 @@ extern "C" std::vector< std::pair<hipModule_t, bool> >* __hipRegisterFatBinary(c
   return programs;
 }
 
+void PlatformState::unregisterVar(hipModule_t hmod) {
+  auto it = vars_.begin();
+  while (it != vars_.end()) {
+    DeviceVar& dvar = it->second;
+    if ((*dvar.modules)[0].first == hmod) {
+      delete dvar.modules;
+      vars_.erase(it++);
+    } else {
+      ++it;
+    }
+  }
+}
+
 void PlatformState::registerVar(const void* hostvar,
                                 const DeviceVar& rvar) {
   amd::ScopedLock lock(lock_);
-  vars_.insert(std::make_pair(hostvar, rvar));
+  vars_.insert(std::make_pair(std::string(reinterpret_cast<const char*>(hostvar)), rvar));
 }
 
 void PlatformState::registerFunction(const void* hostFunction,
@@ -253,11 +266,10 @@ bool PlatformState::getFuncAttr(const void* hostFunction,
   return true;
 }
 
-
 bool PlatformState::getGlobalVar(const void* hostVar, int deviceId,
                                  hipDeviceptr_t* dev_ptr, size_t* size_ptr) {
   amd::ScopedLock lock(lock_);
-  const auto it = vars_.find(hostVar);
+  const auto it = vars_.find(std::string(reinterpret_cast<const char*>(hostVar)));
   if (it != vars_.cend()) {
     DeviceVar& dvar = it->second;
     if (dvar.rvars[deviceId].getdeviceptr() == nullptr) {