Add support for the hipFuncGetAttributes interface.

src/hip_module.cpp

@@ -27,10 +27,11 @@ THE SOFTWARE.
 #include "hsa_helpers.hpp"
 #include "trace_helper.h"
 
+#include <hsa/amd_hsa_kernel_code.h>
 #include <hsa/hsa.h>
 #include <hsa/hsa_ext_amd.h>
-#include <hsa/amd_hsa_kernel_code.h>
 
+#include <algorithm>
 #include <cassert>
 #include <cstdint>
 #include <cstdio>
@@ -71,9 +72,8 @@ struct ihipKernArgInfo {
 map<string, ihipKernArgInfo> kernelArguments;
 
 struct ihipModuleSymbol_t {
-    uint64_t _object;  // The kernel object.
-    uint32_t _groupSegmentSize;
-    uint32_t _privateSegmentSize;
+    uint64_t _object{};  // The kernel object.
+    amd_kernel_code_t const* _header{};
     string _name;  // TODO - review for performance cost.  Name is just used for debug.
 };
 
@@ -179,8 +179,10 @@ hipError_t ihipModuleLaunchKernel(hipFunction_t f, uint32_t globalWorkSizeX,
         aql.grid_size_x = globalWorkSizeX;
         aql.grid_size_y = globalWorkSizeY;
         aql.grid_size_z = globalWorkSizeZ;
-        aql.group_segment_size = f->_groupSegmentSize + sharedMemBytes;
-        aql.private_segment_size = f->_privateSegmentSize;
+        aql.group_segment_size =
+            f->_header->workgroup_group_segment_byte_size + sharedMemBytes;
+        aql.private_segment_size =
+            f->_header->workitem_private_segment_byte_size;
         aql.kernel_object = f->_object;
         aql.setup = 3 << HSA_KERNEL_DISPATCH_PACKET_SETUP_DIMENSIONS;
         aql.header =
@@ -444,10 +446,10 @@ hipError_t ihipModuleGetFunction(hipFunction_t* func, hipModule_t hmod, const ch
 
     if (kernel.handle == 0u) return hipErrorNotFound;
 
-    (*func)->_object = kernel_object(kernel);
-    (*func)->_groupSegmentSize = group_size(kernel);
-    (*func)->_privateSegmentSize = private_size(kernel);
-    (*func)->_name = name;
+    // TODO: refactor the whole ihipThisThat, which is a mess and yields the
+    //       below, due to hipFunction_t being a pointer to ihipModuleSymbol_t.
+    func[0][0] = *static_cast<hipFunction_t>(
+        Kernel_descriptor{kernel_object(kernel), name});
 
     return hipSuccess;
 }
@@ -471,6 +473,61 @@ hipError_t hipModuleGetGlobal(hipDeviceptr_t* dptr, size_t* bytes, hipModule_t h
     return ihipLogStatus(r);
 }
 
+namespace
+{
+    inline
+    hipFuncAttributes make_function_attributes(const amd_kernel_code_t& header)
+    {
+        hipFuncAttributes r{};
+
+        hipDeviceProp_t prop{};
+        hipGetDeviceProperties(
+            &prop, ihipGetTlsDefaultCtx()->getDevice()->_deviceId);
+
+        r.localSizeBytes = header.workitem_private_segment_byte_size;
+        r.sharedSizeBytes = header.workgroup_group_segment_byte_size;
+        r.maxDynamicSharedSizeBytes =
+            prop.sharedMemPerBlock - r.sharedSizeBytes;
+        r.numRegs = header.workitem_vgpr_count;
+        r.maxThreadsPerBlock = r.numRegs ? // TODO: proper query.
+            std::min(prop.maxThreadsPerBlock, 64 * 1024 / r.numRegs) :
+            prop.maxThreadsPerBlock;
+        r.binaryVersion =
+            header.amd_machine_version_major * 10 +
+            header.amd_machine_version_minor;
+        r.ptxVersion = prop.major * 10 + prop.minor; // HIP currently presents itself as PTX 3.0.
+
+        return r;
+    }
+}
+
+hipError_t hipFuncGetAttributes(hipFuncAttributes* attr, const void* func)
+{
+    if (!func) return hipErrorInvalidDeviceFunction;
+
+    const auto it0 = functions().find(reinterpret_cast<uintptr_t>(func));
+
+    if (it0 == functions().cend()) return hipErrorInvalidDeviceFunction;
+
+    auto agent = this_agent();
+    const auto it1 = find_if(
+        it0->second.cbegin(),
+        it0->second.cend(),
+        [=](const pair<hsa_agent_t, Kernel_descriptor>& x) {
+        return x.first == agent;
+    });
+
+    if (it1 == it0->second.cend()) return hipErrorInvalidDeviceFunction;
+
+    const auto header = static_cast<hipFunction_t>(it1->second)->_header;
+
+    if (!header) throw runtime_error{"Ill-formed Kernel_descriptor."};
+
+    *attr = make_function_attributes(*header);
+
+    return hipSuccess;
+}
+
 hipError_t ihipModuleLoadData(hipModule_t* module, const void* image) {
 
     if (!module) return hipErrorInvalidValue;
@@ -487,7 +544,7 @@ hipError_t ihipModuleLoadData(hipModule_t* module, const void* image) {
 
     (*module)->executable = hip_impl::load_executable(
         tmp.empty() ? read_elf_file_as_string(image) : tmp, (*module)->executable, this_agent());
-    
+
     return (*module)->executable.handle ? hipSuccess : hipErrorUnknown;
 }