AI/rocm-systems
2
0
Atdalīts 0
Kods Problēmas Izmaiņu pieprasījumi Darbības Pakotnes Projekti Laidieni Vikivietne Aktivitāte

P4 to Git Change 1311256 by lmoriche@lmoriche_opencl_dev on 2016/09/06 13:16:58

Pārlūkot izejas kodu 
SWDEV-101853 - roc::Kernel cleanups:
	- Remove unused classes & member functions/variables.
	- Flatten vector arguments for the HSAIL path to  remove the need for numElem_.
	- Consolidate initArguments in a single loop for the HSAIL path.
	- Use the Kernel::Argument to fill the OCL descriptor as much as possible.
	- Set the access qualifier for both buffers and images.
	- Fix the indentation and coding conventions.
	- Add new ROC_ARG_TYPE type for hidden arguments
	- Add an index_ field the roc::Kernel::Argument to record the OCL signature index for this argument, or -1 for hidden arguments
	- Handle the hidden arguments as any other argument at dispatch (now included in the hsailArgList_)
	- roc::Kernel::hsailArgAt(int) now returns the kernel argument for the given position in the OCL signature, not the position the the hsailArgList_.

Affected files ...

... //depot/stg/opencl/drivers/opencl/runtime/device/rocm/rockernel.cpp#12 edit
... //depot/stg/opencl/drivers/opencl/runtime/device/rocm/rockernel.hpp#6 edit
... //depot/stg/opencl/drivers/opencl/runtime/device/rocm/rocvirtual.cpp#12 edit


[ROCm/clr commit: 1c37625aa2]
Šī revīzija ir iekļauta:
foreman
2016-09-06 13:21:14 -04:00
vecāks e4f95d2cc7
revīzija d5898bbcfc
3 mainīti faili ar 629 papildinājumiem un 786 dzēšanām
Lejupielādēt ielāpa failu Lejupielādēt izmaiņu failu Izvērst visus failus Savērst visus failus
projects/clr/rocclr/runtime/device/rocm/rockernel.cpp
+468 -589
Parādīt failu
Failā izmaiņas netiks attēlotas, jo tās ir par lielu Ielādēt izmaiņas
projects/clr/rocclr/runtime/device/rocm/rockernel.hpp
+75 -99
Parādīt failu
@@ -14,106 +14,82 @@
namespace roc {
#define MAX_INFO_STRING_LEN 0x40
enum HSAIL_ADDRESS_QUALIFIER{
HSAIL_ADDRESS_ERROR=0,
HSAIL_ADDRESS_GLOBAL,
HSAIL_ADDRESS_LOCAL,
HSAIL_MAX_ADDRESS_QUALIFIERS
} ;
enum HSAIL_ARG_TYPE{
HSAIL_ARGTYPE_ERROR=0,
HSAIL_ARGTYPE_POINTER,
HSAIL_ARGTYPE_VALUE,
HSAIL_ARGTYPE_IMAGE,
HSAIL_ARGTYPE_SAMPLER,
HSAIL_ARGMAX_ARG_TYPES
};
enum HSAIL_DATA_TYPE{
HSAIL_DATATYPE_ERROR=0,
HSAIL_DATATYPE_B1,
HSAIL_DATATYPE_B8,
HSAIL_DATATYPE_B16,
HSAIL_DATATYPE_B32,
HSAIL_DATATYPE_B64,
HSAIL_DATATYPE_S8,
HSAIL_DATATYPE_S16,
HSAIL_DATATYPE_S32,
HSAIL_DATATYPE_S64,
HSAIL_DATATYPE_U8,
HSAIL_DATATYPE_U16,
HSAIL_DATATYPE_U32,
HSAIL_DATATYPE_U64,
HSAIL_DATATYPE_F16,
HSAIL_DATATYPE_F32,
HSAIL_DATATYPE_F64,
HSAIL_DATATYPE_STRUCT,
HSAIL_DATATYPE_OPAQUE,
HSAIL_DATATYPE_MAX_TYPES
};
enum HSAIL_ACCESS_TYPE {
HSAIL_ACCESS_TYPE_NONE = 0,
HSAIL_ACCESS_TYPE_RO,
HSAIL_ACCESS_TYPE_WO,
HSAIL_ACCESS_TYPE_RW
};
struct HsailKernelArg
enum ROC_ARG_TYPE
{
std::string name_; //!< Argument's name
std::string typeName_; //!< Argument's type name
uint size_; //!< Size in bytes
uint offset_; //!< Argument's offset
uint alignment_; //!< Argument's alignment
HSAIL_ARG_TYPE type_; //!< Type of the argument
HSAIL_ADDRESS_QUALIFIER addrQual_; //!< Address qualifier of the argument
HSAIL_DATA_TYPE dataType_; //!< The type of data
uint numElem_; //!< Number of elements
HSAIL_ACCESS_TYPE access_; //!< Access type for the argument
ROC_ARGTYPE_ERROR = 0,
ROC_ARGTYPE_POINTER,
ROC_ARGTYPE_VALUE,
ROC_ARGTYPE_IMAGE,
ROC_ARGTYPE_SAMPLER,
ROC_ARGTYPE_HIDDEN_GLOBAL_OFFSET_X,
ROC_ARGTYPE_HIDDEN_GLOBAL_OFFSET_Y,
ROC_ARGTYPE_HIDDEN_GLOBAL_OFFSET_Z,
ROC_ARGTYPE_HIDDEN_PRINTF_BUFFER,
ROC_ARGTYPE_HIDDEN_DEFAULT_QUEUE,
ROC_ARGTYPE_HIDDEN_COMPLETION_ACTION,
ROC_ARGTYPE_HIDDEN_NONE,
ROC_ARGMAX_ARG_TYPES
};
class KernelArg
enum ROC_ADDRESS_QUALIFIER
{
public:
KernelArg(aclArgData* argInfo);
//! Return type of the argument
clk_value_type_t amdoclType();
//! Global, local etc - returns amdocl types
clk_address_space_t amdoclAddrQual();
//! Global,localetc - returns opencl type
cl_kernel_arg_address_qualifier oclAddrQual();
//! read , write etc - returns amdocl type
clk_arg_qualifier_t amdoclAccessQual();
//! read , write etc - returns opencl type type
cl_kernel_arg_access_qualifier oclAccessQual();
//! const,volatile,restrict etc - returns opencl type type
cl_kernel_arg_type_qualifier oclTypeQual();
ROC_ADDRESS_ERROR = 0,
ROC_ADDRESS_GLOBAL,
ROC_ADDRESS_CONSTANT,
ROC_ADDRESS_LOCAL,
ROC_MAX_ADDRESS_QUALIFIERS
};
//! Name of the argument
std::string& name();
//! Name of the argument
std::string& typeName();
//! reflection
std::string reflection(){ return name(); };
//! Returns the size of the argument
int size();
//! returns the offset
int offset();
enum ROC_DATA_TYPE
{
ROC_DATATYPE_ERROR = 0,
ROC_DATATYPE_B1,
ROC_DATATYPE_B8,
ROC_DATATYPE_B16,
ROC_DATATYPE_B32,
ROC_DATATYPE_B64,
ROC_DATATYPE_S8,
ROC_DATATYPE_S16,
ROC_DATATYPE_S32,
ROC_DATATYPE_S64,
ROC_DATATYPE_U8,
ROC_DATATYPE_U16,
ROC_DATATYPE_U32,
ROC_DATATYPE_U64,
ROC_DATATYPE_F16,
ROC_DATATYPE_F32,
ROC_DATATYPE_F64,
ROC_DATATYPE_STRUCT,
ROC_DATATYPE_OPAQUE,
ROC_DATATYPE_MAX_TYPES
};
void setOffset();
private:
aclArgData* argInfo_;
int offset_;
std::string name_;
std::string typeName_;
enum ROC_ACCESS_TYPE
{
ROC_ACCESS_TYPE_NONE = 0,
ROC_ACCESS_TYPE_RO,
ROC_ACCESS_TYPE_WO,
ROC_ACCESS_TYPE_RW
};
class Kernel : public device::Kernel
{
public:
struct Argument
{
uint index_; //!< Argument's index in the OCL signature
std::string name_; //!< Argument's name
std::string typeName_; //!< Argument's type name
uint size_; //!< Size in bytes
uint alignment_; //!< Argument's alignment
uint pointeeAlignment_; //!< Alignment of the data pointed to
ROC_ARG_TYPE type_; //!< Type of the argument
ROC_ADDRESS_QUALIFIER addrQual_; //!< Address qualifier of the argument
ROC_DATA_TYPE dataType_; //!< The type of data
ROC_ACCESS_TYPE access_; //!< Access type for the argument
};
Kernel(std::string name,
HSAILProgram* prog,
const uint64_t &kernelCodeHandle,
@@ -147,7 +123,6 @@ public:
//! Initializes the metadata required for this kernel
bool init();
#if defined(WITH_LIGHTNING_COMPILER)
//! Initializes the metadata required for this kernel
bool init_LC();
@@ -157,9 +132,15 @@ public:
return static_cast<const HSAILProgram*>(program_);
}
//! Returns the kernel argument list
const std::vector<Argument*>& hsailArgs() const {
return hsailArgList_;
}
//! Returns a pointer to the hsail argument at the specified index
HsailKernelArg* hsailArgAt(size_t index) const {
return hsailArgList_[index];
Argument* hsailArgAt(size_t index) const {
for (auto arg : hsailArgList_) if (arg->index_ == index) return arg;
assert(!"Should not reach here");
}
//! Max number of possible extra (hidden) kernel arguments
@@ -172,22 +153,17 @@ public:
private:
//! Populates hsailArgList_
void initArgList(const aclArgData* aclArg);
//! Initializes Hsail Argument metadata and info ;
void initHsailArgs(const aclArgData* aclArg);
void initArguments(const aclArgData* aclArg);
#if defined(WITH_LIGHTNING_COMPILER)
//! Initializes Hsail Argument metadata and info for LC
void initArgsParams( const amd::hsa::code::KernelArg::Metadata* lcArg, size_t* kOffset,
device::Kernel::parameters_t& params, size_t* pOffset );
void initArguments_LC(const amd::hsa::code::Kernel::Metadata& kernelMD);
#endif // defined(WITH_LIGHTNING_COMPILER)
//! Initializes HSAIL Printf metadata and info
void initPrintf(const aclPrintfFmt* aclPrintf);
HSAILProgram *program_; //!< The roc::HSAILProgram context
std::vector<HsailKernelArg*> hsailArgList_; //!< Vector list of HSAIL Arguments
std::vector<Argument*> hsailArgList_; //!< Vector list of HSAIL Arguments
std::string compileOptions_; //!< compile used for finalizing this kernel
uint64_t kernelCodeHandle_; //!< Kernel code handle (aka amd_kernel_code_t)
const uint32_t workgroupGroupSegmentByteSize_;
projects/clr/rocclr/runtime/device/rocm/rocvirtual.cpp
+86 -98
Parādīt failu
@@ -7,12 +7,12 @@
#include "device/rocm/rockernel.hpp"
#include "device/rocm/rocmemory.hpp"
#include "device/rocm/rocblit.hpp"
#include "../../platform/kernel.hpp"
#include "../../platform/context.hpp"
#include "../../platform/command.hpp"
#include "../../platform/memory.hpp"
#include "../../platform/sampler.hpp"
#include "../../utils/debug.hpp"
#include "platform/kernel.hpp"
#include "platform/context.hpp"
#include "platform/command.hpp"
#include "platform/memory.hpp"
#include "platform/sampler.hpp"
#include "utils/debug.hpp"
#include "os/os.hpp"
#include "SCHSAInterface.h"
#include "amd_hsa_kernel_code.h"
@@ -87,10 +87,10 @@ double Timestamp::ticksToTime_=0;
* to correlate the cl kernel launch and HSA kernel dispatch
*/
typedef hsa_status_t
(*hsa_ext_tools_set_correlation_handle)(const hsa_agent_t agent,
(*hsa_ext_tools_set_correlation_handle)(const hsa_agent_t agent,
void *correlation_handle);
static void SetOclCorrelationHandle(void *tools_lib, const hsa_agent_t agent, void *handle) {
hsa_ext_tools_set_correlation_handle func =
hsa_ext_tools_set_correlation_handle func =
(hsa_ext_tools_set_correlation_handle)amd::Os::getSymbol(tools_lib, "hsa_ext_tools_set_correlation_handler");
if (func) {
func(agent, handle);
@@ -276,13 +276,13 @@ VirtualGPU::processMemObjects(
// Check all parameters for the current kernel
for (size_t i = 0; i < signature.numParameters(); ++i) {
const amd::KernelParameterDescriptor& desc = signature.at(i);
const HsailKernelArg* arg = hsaKernel.hsailArgAt(i);
const Kernel::Argument* arg = hsaKernel.hsailArgAt(i);
Memory* memory = NULL;
bool readOnly = false;
amd::Memory* svmMem = NULL;
// Find if current argument is a buffer
if ((desc.type_ == T_POINTER) && (arg->addrQual_ != HSAIL_ADDRESS_LOCAL)) {
if ((desc.type_ == T_POINTER) && (arg->addrQual_ != ROC_ADDRESS_LOCAL)) {
if (kernelParams.boundToSvmPointer(dev(), params, i)) {
svmMem = amd::SvmManager::FindSvmBuffer(
*reinterpret_cast<void* const*>(params + desc.offset_));
@@ -308,11 +308,7 @@ VirtualGPU::processMemObjects(
}
if (memory != NULL) {
// Check image
readOnly = (desc.accessQualifier_ ==
CL_KERNEL_ARG_ACCESS_READ_ONLY) ? true : false;
// Check buffer
readOnly |= (arg->access_ == HSAIL_ACCESS_TYPE_RO) ? true : false;
readOnly |= (arg->access_ == ROC_ACCESS_TYPE_RO);
// Validate memory for a dependency in the queue
memoryDependency().validate(*this, memory, readOnly);
}
@@ -977,7 +973,7 @@ void VirtualGPU::submitSvmCopyMemory(amd::SvmCopyMemoryCommand& cmd)
// in-order semantics: previous commands need to be done before we start
releaseGpuMemoryFence();
profilingBegin(cmd);
amd::SvmBuffer::memFill(cmd.dst(), cmd.src(), cmd.srcSize(), 1);
amd::SvmBuffer::memFill(cmd.dst(), cmd.src(), cmd.srcSize(), 1);
profilingEnd(cmd);
}
@@ -1362,34 +1358,33 @@ void VirtualGPU::submitMigrateMemObjects(amd::MigrateMemObjectsCommand &vcmd)
profilingEnd(vcmd);
}
/*! \brief Writes to the buffer and incrememts the write pointer to the
/*! \brief Writes to the buffer and increments the write pointer to the
* buffer. Also, ensures that the argument is written to an
* aligned memory as specified
* aligned memory as specified. Return the new write pointer.
*
* @param dst The write pointer to the buffer
* @param src The source pointer
* @param size The size in bytes to copy
* @param alignment The alignment to follow while writing to the buffer
*/
static void
addArg(unsigned char** dst, const void* src,
size_t size, uint32_t alignment)
static inline address
addArg(address dst, const void* src, size_t size, uint32_t alignment)
{
*dst = amd::alignUp(*dst, alignment);
memcpy(*dst, src, size);
*dst += size;
dst = amd::alignUp(dst, alignment);
::memcpy(dst, src, size);
return dst + size;
}
static inline void
addArg(unsigned char** dst, const void* src, size_t size)
static inline address
addArg(address dst, const void* src, size_t size)
{
assert(size < UINT32_MAX);
addArg(dst, src, size, size);
return addArg(dst, src, size, size);
}
//Over rides the workgroup size fields in the packet with runtime/compiler set sizes
void setRuntimeCompilerLocalSize(hsa_kernel_dispatch_packet_t& dispatchPacket,
amd::NDRangeContainer sizes,
//Over rides the workgroup size fields in the packet with runtime/compiler set sizes
void setRuntimeCompilerLocalSize(hsa_kernel_dispatch_packet_t& dispatchPacket,
amd::NDRangeContainer sizes,
const size_t* compile_size,
const roc::Device &dev){
//Todo (sramalin) need to check if compile_size is set to 0 if dimension is not valid
@@ -1467,9 +1462,10 @@ VirtualGPU::submitKernelInternal(
SetOclCorrelationHandle(tools_lib_, this->gpu_device_, eventHandle);
}
device::Kernel *devKernel = const_cast<device::Kernel *>
(kernel.getDeviceKernel(dev()));
device::Kernel *devKernel = const_cast<device::Kernel*>(
kernel.getDeviceKernel(dev()));
Kernel &gpuKernel = static_cast<Kernel &>(*devKernel);
const size_t compilerLdsUsage = gpuKernel.WorkgroupGroupSegmentByteSize();
size_t ldsUsage = compilerLdsUsage;
@@ -1487,9 +1483,9 @@ VirtualGPU::submitKernelInternal(
}
// Allocate buffer to hold kernel arguments
address argBuffer =
(address)allocKernArg(gpuKernel.KernargSegmentByteSize(),
gpuKernel.KernargSegmentAlignment());
address argBuffer = (address)allocKernArg(
gpuKernel.KernargSegmentByteSize(),
gpuKernel.KernargSegmentAlignment());
if (argBuffer == NULL) {
LogError("Out of memory");
@@ -1497,55 +1493,69 @@ VirtualGPU::submitKernelInternal(
}
address argPtr = argBuffer;
#if !defined(WITH_LIGHTNING_COMPILER)
// The HLC generates Kernenv arguments, first 3 are global offsets.
const uint extraAargs = ((roc::Kernel*)devKernel)->extraArgumentsNum();
for (uint j = 0; j < extraAargs; ++j) {
// The 4th parameter is the pointer to print buffer
if (3 == j) {
address bufferPtr = printfDbg()->dbgBuffer();
addArg(&argPtr, &bufferPtr, sizeof(void*));
}else {
const size_t offset = j < sizes.dimensions() ? sizes.offset()[j] : 0;
addArg(&argPtr, &offset, sizeof(void*)); //Should be uint32_t for small model and uint64_t for large!
}
}
#endif // defined(WITH_LIGHTNING_COMPILER)
const amd::KernelSignature& signature = kernel.signature();
const amd::KernelParameters& kernelParams = kernel.parameters();
// Find all parameters for the current kernel
for (uint i = 0; i != signature.numParameters(); ++i) {
const HsailKernelArg* arg = gpuKernel.hsailArgAt(i);
const_address srcArgPtr = parameters + signature.at(i).offset_;
for (auto arg : gpuKernel.hsailArgs()) {
// Handle the hidden arguments first, as they do not have a
// matching parameter in the OCL signature (not a valid arg->index_)
if (arg->type_ == ROC_ARGTYPE_HIDDEN_GLOBAL_OFFSET_X) {
size_t offset_x = sizes.dimensions() >= 1 ? sizes.offset()[0] : 0;
argPtr = addArg(argPtr, &offset_x, sizeof(void*));
continue;
}
else if (arg->type_ == ROC_ARGTYPE_HIDDEN_GLOBAL_OFFSET_Y) {
size_t offset_y = sizes.dimensions() >= 2 ? sizes.offset()[1] : 0;
argPtr = addArg(argPtr, &offset_y, sizeof(void*));
continue;
}
else if (arg->type_ == ROC_ARGTYPE_HIDDEN_GLOBAL_OFFSET_Z) {
size_t offset_z = sizes.dimensions() == 3 ? sizes.offset()[2] : 0;
argPtr = addArg(argPtr, &offset_z, sizeof(void*));
continue;
}
else if (arg->type_ == ROC_ARGTYPE_HIDDEN_PRINTF_BUFFER) {
address bufferPtr = printfDbg()->dbgBuffer();
argPtr = addArg(argPtr, &bufferPtr, sizeof(void*));
continue;
}
else if (arg->type_ == ROC_ARGTYPE_HIDDEN_DEFAULT_QUEUE
|| arg->type_ == ROC_ARGTYPE_HIDDEN_COMPLETION_ACTION
|| arg->type_ == ROC_ARGTYPE_HIDDEN_NONE) {
void* zero = 0;
argPtr = addArg(argPtr, &zero, sizeof(void*));
continue;
}
if (arg->type_ == HSAIL_ARGTYPE_POINTER ) {
const size_t size = arg->size_;
if (arg->addrQual_ == HSAIL_ADDRESS_LOCAL) {
assert(arg->index_ != uint(-1) && "not a valid signature index");
const_address srcArgPtr = parameters + signature.at(arg->index_).offset_;
if (arg->type_ == ROC_ARGTYPE_POINTER) {
if (arg->addrQual_ == ROC_ADDRESS_LOCAL) {
// Align the LDS on the alignment requirement of type pointed to
ldsUsage = amd::alignUp(ldsUsage, arg->alignment_);
addArg(&argPtr, &ldsUsage, size);
ldsUsage = amd::alignUp(ldsUsage, arg->pointeeAlignment_);
argPtr = addArg(argPtr, &ldsUsage, arg->size_, arg->alignment_);
ldsUsage += *reinterpret_cast<const size_t *>(srcArgPtr);
continue;
}
assert((arg->addrQual_ == HSAIL_ADDRESS_GLOBAL) &&
"Unsupported address qualifier");
if (kernelParams.boundToSvmPointer(dev(), parameters, i)) {
addArg(&argPtr, srcArgPtr, size);
assert((arg->addrQual_ == ROC_ADDRESS_GLOBAL
|| arg->addrQual_ == ROC_ADDRESS_CONSTANT)
&& "Unsupported address qualifier");
if (kernelParams.boundToSvmPointer(dev(), parameters, arg->index_)) {
argPtr = addArg(argPtr, srcArgPtr, arg->size_, arg->alignment_);
continue;
}
amd::Memory* mem = *reinterpret_cast<amd::Memory* const*>(srcArgPtr);
if (mem == NULL) {
addArg(&argPtr, srcArgPtr, size);
argPtr = addArg(argPtr, srcArgPtr, arg->size_, arg->alignment_);
continue;
}
Memory *devMem = static_cast<Memory *>(mem->getDeviceMemory(dev()));
//! @todo add multi-devices synchronization when supported.
void* globalAddress = devMem->getDeviceMemory();
addArg(&argPtr, &globalAddress, size);
argPtr = addArg(argPtr, &globalAddress, arg->size_, arg->alignment_);
//! @todo Compiler has to return read/write attributes
const cl_mem_flags flags = mem->getMemFlags();
@@ -1553,23 +1563,21 @@ VirtualGPU::submitKernelInternal(
mem->signalWrite(&dev());
}
}
else if (arg->type_ == HSAIL_ARGTYPE_VALUE) {
if (arg->dataType_ == HSAIL_DATATYPE_STRUCT) {
else if (arg->type_ == ROC_ARGTYPE_VALUE) {
if (arg->dataType_ == ROC_DATATYPE_STRUCT) {
void *mem = allocKernArg(arg->size_, arg->alignment_);
if (mem == NULL) {
LogError("Out of memory");
return false;
}
memcpy(mem, srcArgPtr, arg->size_);
addArg(&argPtr, &mem, sizeof(void*));
argPtr = addArg(argPtr, &mem, sizeof(void*));
continue;
}
for (uint e = 0; e < arg->numElem_; ++e) {
addArg(&argPtr, srcArgPtr, arg->size_);
srcArgPtr += arg->size_;
}
argPtr = addArg(argPtr, srcArgPtr, arg->size_, arg->alignment_);
srcArgPtr += arg->size_;
}
else if (arg->type_ == HSAIL_ARGTYPE_IMAGE) {
else if (arg->type_ == ROC_ARGTYPE_IMAGE) {
amd::Memory* mem = *reinterpret_cast<amd::Memory* const*>(srcArgPtr);
Image* image = static_cast<Image *>(mem->getDeviceMemory(dev()));
if (image == NULL) {
@@ -1580,11 +1588,11 @@ VirtualGPU::submitKernelInternal(
if (dev().settings().enableImageHandle_) {
const uint64_t image_srd = image->getHsaImageObject().handle;
assert(amd::isMultipleOf(image_srd, sizeof(image_srd)));
addArg(&argPtr, &image_srd, sizeof(image_srd));
argPtr = addArg(argPtr, &image_srd, sizeof(image_srd));
}
else {
// Image arguments are of size 48 bytes and are aligned to 16 bytes
addArg(&argPtr, (void *)image->getHsaImageObject().handle,
argPtr = addArg(argPtr, (void *)image->getHsaImageObject().handle,
HSA_IMAGE_OBJECT_SIZE, HSA_IMAGE_OBJECT_ALIGNMENT);
}
@@ -1594,7 +1602,7 @@ VirtualGPU::submitKernelInternal(
mem->signalWrite(&dev());
}
}
else if (arg->type_ == HSAIL_ARGTYPE_SAMPLER) {
else if (arg->type_ == ROC_ARGTYPE_SAMPLER) {
amd::Sampler* sampler = *reinterpret_cast<amd::Sampler* const*>(srcArgPtr);
if (sampler == NULL) {
LogError("Kernel sampler argument is not an sampler object");
@@ -1614,7 +1622,7 @@ VirtualGPU::submitKernelInternal(
if (dev().settings().enableImageHandle_) {
uint64_t sampler_srd = hsa_sampler.handle;
addArg(&argPtr, &sampler_srd, sizeof(sampler_srd));
argPtr = addArg(argPtr, &sampler_srd, sizeof(sampler_srd));
samplerList_.push_back(hsa_sampler);
// TODO: destroy sampler.
}
@@ -1628,26 +1636,6 @@ VirtualGPU::submitKernelInternal(
}
}
#if defined(WITH_LIGHTNING_COMPILER)
const uint extraAargs = ((roc::Kernel*)devKernel)->extraArgumentsNum();
for (uint j = 0; j < extraAargs; ++j) {
switch(j) {
case 3: { // Printf buffer
address bufferPtr = printfDbg()->dbgBuffer();
addArg(&argPtr, &bufferPtr, sizeof(void*));
break;
}
case 0: case 1: case 2: { // Global offsets
const size_t offset = j < sizes.dimensions() ? sizes.offset()[j] : 0;
addArg(&argPtr, &offset, sizeof(size_t));
break;
}
default:
assert(!"Unknown hidden argument index");
}
}
#endif // defined(WITH_LIGHTNING_COMPILER)
// Check there is no arguments' buffer overflow
assert(argPtr <= argBuffer + gpuKernel.KernargSegmentByteSize());
@@ -1662,7 +1650,7 @@ VirtualGPU::submitKernelInternal(
//Initialize the dispatch Packet
hsa_kernel_dispatch_packet_t dispatchPacket;
memset(&dispatchPacket, 0, sizeof(dispatchPacket));
dispatchPacket.kernel_object = gpuKernel.KernelCodeHandle();
dispatchPacket.header = aqlHeader_;