P4 to Git Change 1521675 by lmoriche@lmoriche_opencl_dev2 on 2018/03/01 22:50:06

SWDEV-145570 - [HIP] - Hip Rearchitecture
	- Add initial prototype implementation

Affected files ...

... //depot/stg/opencl/drivers/opencl/api/Makefile#11 edit
... //depot/stg/opencl/drivers/opencl/api/hip/fixme.cpp#1 add
... //depot/stg/opencl/drivers/opencl/api/hip/hip_context.cpp#1 add
... //depot/stg/opencl/drivers/opencl/api/hip/hip_device.cpp#2 edit
... //depot/stg/opencl/drivers/opencl/api/hip/hip_error.cpp#1 add
... //depot/stg/opencl/drivers/opencl/api/hip/hip_event.cpp#1 add
... //depot/stg/opencl/drivers/opencl/api/hip/hip_hcc.def.in#1 add
... //depot/stg/opencl/drivers/opencl/api/hip/hip_hcc.map.in#1 add
... //depot/stg/opencl/drivers/opencl/api/hip/hip_hcc.rc#1 add
... //depot/stg/opencl/drivers/opencl/api/hip/hip_internal.hpp#2 edit
... //depot/stg/opencl/drivers/opencl/api/hip/hip_memory.cpp#3 edit
... //depot/stg/opencl/drivers/opencl/api/hip/hip_module.cpp#1 add
... //depot/stg/opencl/drivers/opencl/api/hip/hip_platform.cpp#1 add

api/hip/hip_module.cpp

@@ -0,0 +1,144 @@
+/*
+Copyright (c) 2015 - present Advanced Micro Devices, Inc. All rights reserved.
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.
+*/
+
+#include <hip/hip_runtime.h>
+#include <libelf.h>
+
+#include "hip_internal.hpp"
+#include "platform/program.hpp"
+
+static uint64_t ElfSize(const void *emi)
+{
+  const Elf64_Ehdr *ehdr = (const Elf64_Ehdr*)emi;
+  const Elf64_Shdr *shdr = (const Elf64_Shdr*)((char*)emi + ehdr->e_shoff);
+
+  uint64_t max_offset = ehdr->e_shoff;
+  uint64_t total_size = max_offset + ehdr->e_shentsize * ehdr->e_shnum;
+
+  for (uint16_t i=0; i < ehdr->e_shnum; ++i){
+    uint64_t cur_offset = static_cast<uint64_t>(shdr[i].sh_offset);
+    if (max_offset < cur_offset) {
+      max_offset = cur_offset;
+      total_size = max_offset;
+      if(SHT_NOBITS != shdr[i].sh_type) {
+        total_size += static_cast<uint64_t>(shdr[i].sh_size);
+      }
+    }
+  }
+  return total_size;
+}
+
+hipError_t hipModuleLoadData(hipModule_t *module, const void *image)
+{
+  HIP_INIT_API(module, image);
+
+  amd::Program* program = new amd::Program(*g_context);
+  if (program == NULL) {
+    return hipErrorOutOfMemory;
+  }
+
+  if (CL_SUCCESS != program->addDeviceProgram(*g_context->devices()[0], image, ElfSize(image)) ||
+    CL_SUCCESS != program->build(g_context->devices(), nullptr, nullptr, nullptr)) {
+    return hipErrorUnknown;
+  }
+
+  *module = reinterpret_cast<hipModule_t>(as_cl(program));
+
+  return hipSuccess;
+}
+
+hipError_t hipModuleGetFunction(hipFunction_t *hfunc, hipModule_t hmod, const char *name)
+{
+  HIP_INIT_API(hfunc, hmod, name);
+
+  amd::Program* program = as_amd(reinterpret_cast<cl_program>(hmod));
+
+  const amd::Symbol* symbol = program->findSymbol(name);
+  if (!symbol) {
+    return hipErrorNotFound;
+  }
+
+  amd::Kernel* kernel = new amd::Kernel(*program, *symbol, name);
+  if (!kernel) {
+    return hipErrorOutOfMemory;
+  }
+
+  *hfunc = reinterpret_cast<hipFunction_t>(as_cl(kernel));
+
+  return hipSuccess;
+}
+
+hipError_t hipModuleLaunchKernel(hipFunction_t f,
+                                 uint32_t gridDimX, uint32_t gridDimY, uint32_t gridDimZ,
+                                 uint32_t blockDimX, uint32_t blockDimY, uint32_t blockDimZ,
+                                 uint32_t sharedMemBytes, hipStream_t hStream,
+                                 void **kernelParams, void **extra)
+{
+  HIP_INIT_API(f, gridDimX, gridDimY, gridDimZ,
+               blockDimX, blockDimY, blockDimZ,
+               sharedMemBytes, hStream,
+               kernelParams, extra);
+
+  amd::Kernel* kernel = as_amd(reinterpret_cast<cl_kernel>(f));
+  amd::Device* device = g_context->devices()[0];
+
+  amd::HostQueue* queue = new amd::HostQueue(*g_context, *device, 0,
+                                             amd::CommandQueue::RealTimeDisabled,
+                                             amd::CommandQueue::Priority::Normal);
+  if (!queue) {
+    return hipErrorOutOfMemory;
+  }
+
+  size_t globalWorkOffset[3] = {0};
+  size_t globalWorkSize[3] = { gridDimX, gridDimY, gridDimZ };
+  size_t localWorkSize[3] = { blockDimX, blockDimY, blockDimZ };
+  amd::NDRangeContainer ndrange(3, globalWorkOffset, globalWorkSize, localWorkSize);
+  amd::Command::EventWaitList waitList;
+
+  assert(!kernelParams && extra && "check this code");
+  const amd::KernelSignature& signature = kernel->signature();
+  for (size_t i = 0; i < signature.numParameters(); ++i) {
+    const amd::KernelParameterDescriptor& desc = signature.at(i);
+    kernel->parameters().set(i, desc.size_, reinterpret_cast<address>(extra[1]) + desc.offset_);
+  }
+
+  amd::NDRangeKernelCommand* command = new amd::NDRangeKernelCommand(*queue, waitList, *kernel, ndrange);
+  if (!command) {
+    return hipErrorOutOfMemory;
+  }
+
+  // Make sure we have memory for the command execution
+  if (CL_SUCCESS != command->validateMemory()) {
+    delete command;
+    return hipErrorMemoryAllocation;
+  }
+
+  command->enqueue();
+  command->awaitCompletion();
+  command->release();
+
+  queue->release();
+
+  return hipSuccess;
+}
+
+