SWDEV-268864 - Use new isa class to access isa related information

Change-Id: I2122bf85155997d802ca54e456c2dae66b801825


[ROCm/hip commit: c45b74c9de]

projects/hip/rocclr/hip_code_object.cpp

@@ -365,7 +365,7 @@ static bool isCodeObjectCompatibleWithDevice(std::string co_triple_target_id,
 
 // This will be moved to COMGR eventually
 hipError_t CodeObject::ExtractCodeObjectFromFile(amd::Os::FileDesc fdesc, size_t fsize,
-                       const std::vector<const char*>& device_names,
+                       const std::vector<std::string>& device_names,
                        std::vector<std::pair<const void*, size_t>>& code_objs) {
 
   hipError_t hip_error = hipSuccess;
@@ -393,7 +393,7 @@ hipError_t CodeObject::ExtractCodeObjectFromFile(amd::Os::FileDesc fdesc, size_t
 
 // This will be moved to COMGR eventually
 hipError_t CodeObject::ExtractCodeObjectFromMemory(const void* data,
-                       const std::vector<const char*>& device_names,
+                       const std::vector<std::string>& device_names,
                        std::vector<std::pair<const void*, size_t>>& code_objs,
                        std::string& uri) {
 
@@ -406,8 +406,8 @@ hipError_t CodeObject::ExtractCodeObjectFromMemory(const void* data,
 }
 
 // This will be moved to COMGR eventually
-hipError_t CodeObject::extractCodeObjectFromFatBinary(const void* data, 
-                       const std::vector<const char*>& agent_triple_target_ids,
+hipError_t CodeObject::extractCodeObjectFromFatBinary(const void* data,
+                       const std::vector<std::string>& agent_triple_target_ids,
                        std::vector<std::pair<const void*, size_t>>& code_objs) {
   std::string magic((const char*)data, bundle_magic_string_size);
   if (magic.compare(CLANG_OFFLOAD_BUNDLER_MAGIC_STR)) {

projects/hip/rocclr/hip_code_object.hpp

@@ -52,13 +52,13 @@ class CodeObject {
   // Given an file desc and file size, extracts to code object for corresponding devices,
   // return code_objs{binary_ptr, binary_size}, which could be used to determine foffset
   static hipError_t ExtractCodeObjectFromFile(amd::Os::FileDesc fdesc, size_t fsize,
-                    const std::vector<const char*>& device_names,
+                    const std::vector<std::string>& device_names,
                     std::vector<std::pair<const void*, size_t>>& code_objs);
 
   // Given an ptr to memory, extracts to code object for corresponding devices,
   // returns code_objs{binary_ptr, binary_size} and uniform resource indicator
   static hipError_t ExtractCodeObjectFromMemory(const void* data,
-                    const std::vector<const char*>& device_names,
+                    const std::vector<std::string>& device_names,
                     std::vector<std::pair<const void*, size_t>>& code_objs,
                     std::string& uri);
 
@@ -68,7 +68,7 @@ protected:
   //Given an ptr to image or file, extracts to code object
   //for corresponding devices
   static hipError_t extractCodeObjectFromFatBinary(const void*,
-                    const std::vector<const char*>&,
+                    const std::vector<std::string>&,
                     std::vector<std::pair<const void*, size_t>>&);
 
   CodeObject() {}

projects/hip/rocclr/hip_device.cpp

@@ -152,6 +152,7 @@ hipError_t hipGetDeviceProperties ( hipDeviceProp_t* props, hipDevice_t device )
   hipDeviceProp_t deviceProps = {0};
 
   const auto& info = deviceHandle->info();
+  const auto& isa = deviceHandle->isa();
   ::strncpy(deviceProps.name, info.boardName_, 128);
   deviceProps.totalGlobalMem = info.globalMemSize_;
   deviceProps.sharedMemPerBlock = info.localMemSizePerCU_;
@@ -168,8 +169,8 @@ hipError_t hipGetDeviceProperties ( hipDeviceProp_t* props, hipDevice_t device )
   deviceProps.memoryClockRate = info.maxMemoryClockFrequency_ * 1000;
   deviceProps.memoryBusWidth = info.globalMemChannels_;
   deviceProps.totalConstMem = info.maxConstantBufferSize_;
-  deviceProps.major = info.gfxipMajor_;
-  deviceProps.minor = info.gfxipMinor_;
+  deviceProps.major = isa.versionMajor();
+  deviceProps.minor = isa.versionMinor();
   deviceProps.multiProcessorCount = info.maxComputeUnits_;
   deviceProps.l2CacheSize = info.l2CacheSize_;
   deviceProps.maxThreadsPerMultiProcessor = info.maxThreadsPerCU_;
@@ -199,8 +200,8 @@ hipError_t hipGetDeviceProperties ( hipDeviceProp_t* props, hipDevice_t device )
   deviceProps.maxSharedMemoryPerMultiProcessor = info.localMemSizePerCU_;
   deviceProps.canMapHostMemory = 1;
   //FIXME: This should be removed, targets can have character names as well.
-  deviceProps.gcnArch = info.gfxipMajor_ * 100 + info.gfxipMinor_ * 10 + info.gfxipStepping_;
-  sprintf(deviceProps.gcnArchName, "%s", info.targetId_);
+  deviceProps.gcnArch = isa.versionMajor() * 100 + isa.versionMinor() * 10 + isa.versionStepping();
+  sprintf(deviceProps.gcnArchName, "%s", isa.targetId());
   deviceProps.cooperativeLaunch = info.cooperativeGroups_;
   deviceProps.cooperativeMultiDeviceLaunch = info.cooperativeMultiDeviceGroups_;
 

projects/hip/rocclr/hip_fatbin.cpp

@@ -51,10 +51,10 @@ hipError_t FatBinaryInfo::ExtractFatBinary(const std::vector<hip::Device*>& devi
   std::vector<std::pair<const void*, size_t>> code_objs;
 
   // Copy device names for Extract Code object File
-  std::vector<const char*> device_names;
+  std::vector<std::string> device_names;
   device_names.reserve(devices.size());
   for (size_t dev_idx = 0; dev_idx < devices.size(); ++dev_idx) {
-    device_names.push_back(devices[dev_idx]->devices()[0]->info().targetId_);
+    device_names.push_back(devices[dev_idx]->devices()[0]->isa().isaName());
   }
 
   // We are given file name, get the file desc and file size

projects/hip/rocclr/hip_module.cpp

@@ -78,7 +78,7 @@ hipError_t hipModuleLoadDataEx(hipModule_t *module, const void *image,
 }
 
 extern hipError_t __hipExtractCodeObjectFromFatBinary(const void* data,
-                                                const std::vector<const char*>& devices,
+                                                const std::vector<std::string>& devices,
                                                 std::vector<std::pair<const void*, size_t>>& code_objs);
 
 hipError_t hipModuleGetFunction(hipFunction_t *hfunc, hipModule_t hmod, const char *name) {