AI/rocm-systems
2
0
Fork 0
Código Incidencias Pull Requests Acciones Paquetes Proyectos Lanzamientos Wiki Actividad

P4 to Git Change 1599157 by gandryey@gera-ocl-lc on 2018/08/28 17:11:04

Explorar el Código 
SWDEV-79445 - OCL generic changes and code clean-up
	- Add devkerenle.cpp/hpp files for device::Kernel object
	- Move generic code for the arguments setup from the device layer to the abstraction layer
	- Update ROCr and PAL paths to utilize the generic logic for the arguments setup

Affected files ...

... //depot/stg/opencl/drivers/opencl/runtime/device/device.cpp#226 edit
... //depot/stg/opencl/drivers/opencl/runtime/device/device.hpp#313 edit
... //depot/stg/opencl/drivers/opencl/runtime/device/devkernel.cpp#1 add
... //depot/stg/opencl/drivers/opencl/runtime/device/devkernel.hpp#1 add
... //depot/stg/opencl/drivers/opencl/runtime/device/gpu/gpukernel.cpp#328 edit
... //depot/stg/opencl/drivers/opencl/runtime/device/gpu/gpukernel.hpp#130 edit
... //depot/stg/opencl/drivers/opencl/runtime/device/pal/palkernel.cpp#61 edit
... //depot/stg/opencl/drivers/opencl/runtime/device/pal/palkernel.hpp#20 edit
... //depot/stg/opencl/drivers/opencl/runtime/device/rocm/rockernel.cpp#40 edit
... //depot/stg/opencl/drivers/opencl/runtime/device/rocm/rockernel.hpp#24 edit
... //depot/stg/opencl/drivers/opencl/runtime/runtimedefs#51 edit
Este commit está contenido en:
foreman
2018-08-28 17:30:29 -04:00
padre 0c5f415b5f
commit 5cfeb120ed
Se han modificado 10 ficheros con 1052 adiciones y 1832 borrados
Descargar archivo de parche Descargar archivo de diferencias Expandir todos los archivos Contraer todos los archivos
rocclr/runtime/device/rocm/rockernel.cpp
+2 -750
Ver fichero
@@ -11,749 +11,6 @@
namespace roc {
#if defined(WITH_LIGHTNING_COMPILER)
using llvm::AMDGPU::HSAMD::AccessQualifier;
using llvm::AMDGPU::HSAMD::AddressSpaceQualifier;
using llvm::AMDGPU::HSAMD::ValueKind;
using llvm::AMDGPU::HSAMD::ValueType;
static inline ROC_ARG_TYPE GetKernelArgType(const KernelArgMD& lcArg) {
switch (lcArg.mValueKind) {
case ValueKind::GlobalBuffer:
case ValueKind::DynamicSharedPointer:
case ValueKind::Pipe:
return ROC_ARGTYPE_POINTER;
case ValueKind::ByValue:
return ROC_ARGTYPE_VALUE;
case ValueKind::Image:
return ROC_ARGTYPE_IMAGE;
case ValueKind::Sampler:
return ROC_ARGTYPE_SAMPLER;
case ValueKind::Queue:
return ROC_ARGTYPE_QUEUE;
case ValueKind::HiddenGlobalOffsetX:
return ROC_ARGTYPE_HIDDEN_GLOBAL_OFFSET_X;
case ValueKind::HiddenGlobalOffsetY:
return ROC_ARGTYPE_HIDDEN_GLOBAL_OFFSET_Y;
case ValueKind::HiddenGlobalOffsetZ:
return ROC_ARGTYPE_HIDDEN_GLOBAL_OFFSET_Z;
case ValueKind::HiddenPrintfBuffer:
return ROC_ARGTYPE_HIDDEN_PRINTF_BUFFER;
case ValueKind::HiddenDefaultQueue:
return ROC_ARGTYPE_HIDDEN_DEFAULT_QUEUE;
case ValueKind::HiddenCompletionAction:
return ROC_ARGTYPE_HIDDEN_COMPLETION_ACTION;
case ValueKind::HiddenNone:
return ROC_ARGTYPE_HIDDEN_NONE;
default:
return ROC_ARGTYPE_ERROR;
}
}
#endif // defined(WITH_LIGHTNING_COMPILER)
static inline ROC_ARG_TYPE GetKernelArgType(const aclArgData* argInfo) {
if (argInfo->argStr[0] == '_' && argInfo->argStr[1] == '.') {
if (strcmp(&argInfo->argStr[2], "global_offset_0") == 0) {
return ROC_ARGTYPE_HIDDEN_GLOBAL_OFFSET_X;
} else if (strcmp(&argInfo->argStr[2], "global_offset_1") == 0) {
return ROC_ARGTYPE_HIDDEN_GLOBAL_OFFSET_Y;
} else if (strcmp(&argInfo->argStr[2], "global_offset_2") == 0) {
return ROC_ARGTYPE_HIDDEN_GLOBAL_OFFSET_Z;
} else if (strcmp(&argInfo->argStr[2], "printf_buffer") == 0) {
return ROC_ARGTYPE_HIDDEN_PRINTF_BUFFER;
} else if (strcmp(&argInfo->argStr[2], "vqueue_pointer") == 0) {
return ROC_ARGTYPE_HIDDEN_DEFAULT_QUEUE;
} else if (strcmp(&argInfo->argStr[2], "aqlwrap_pointer") == 0) {
return ROC_ARGTYPE_HIDDEN_COMPLETION_ACTION;
}
return ROC_ARGTYPE_HIDDEN_NONE;
}
switch (argInfo->type) {
case ARG_TYPE_POINTER:
return ROC_ARGTYPE_POINTER;
case ARG_TYPE_VALUE:
return (argInfo->arg.value.data == DATATYPE_struct) ? ROC_ARGTYPE_REFERENCE
: ROC_ARGTYPE_VALUE;
case ARG_TYPE_IMAGE:
return ROC_ARGTYPE_IMAGE;
case ARG_TYPE_SAMPLER:
return ROC_ARGTYPE_SAMPLER;
case ARG_TYPE_QUEUE:
return ROC_ARGTYPE_QUEUE;
case ARG_TYPE_ERROR:
default:
return ROC_ARGTYPE_ERROR;
}
}
#if defined(WITH_LIGHTNING_COMPILER)
static inline size_t GetKernelArgAlignment(const KernelArgMD& lcArg) { return lcArg.mAlign; }
#endif // defined(WITH_LIGHTNING_COMPILER)
static inline size_t GetKernelArgAlignment(const aclArgData* argInfo) {
switch (argInfo->type) {
case ARG_TYPE_POINTER:
return sizeof(void*);
case ARG_TYPE_VALUE:
switch (argInfo->arg.value.data) {
case DATATYPE_i8:
case DATATYPE_u8:
return 1;
case DATATYPE_u16:
case DATATYPE_i16:
case DATATYPE_f16:
return 2;
case DATATYPE_u32:
case DATATYPE_i32:
case DATATYPE_f32:
return 4;
case DATATYPE_i64:
case DATATYPE_u64:
case DATATYPE_f64:
return 8;
case DATATYPE_struct:
return 128;
case DATATYPE_ERROR:
default:
return -1;
}
case ARG_TYPE_IMAGE:
return sizeof(cl_mem);
case ARG_TYPE_SAMPLER:
return sizeof(cl_sampler);
default:
return -1;
}
}
#if defined(WITH_LIGHTNING_COMPILER)
static inline size_t GetKernelArgPointeeAlignment(const KernelArgMD& lcArg) {
if (lcArg.mValueKind == ValueKind::DynamicSharedPointer) {
uint32_t align = lcArg.mPointeeAlign;
if (align == 0) {
LogWarning("Missing DynamicSharedPointer alignment");
align = 128; /* worst case alignment */
;
}
return align;
}
return 1;
}
#endif // defined(WITH_LIGHTNING_COMPILER)
static inline size_t GetKernelArgPointeeAlignment(const aclArgData* argInfo) {
if (argInfo->type == ARG_TYPE_POINTER) {
return argInfo->arg.pointer.align;
}
return 1;
}
#if defined(WITH_LIGHTNING_COMPILER)
static inline ROC_ACCESS_TYPE GetKernelArgAccessType(const KernelArgMD& lcArg) {
if (lcArg.mValueKind == ValueKind::GlobalBuffer || lcArg.mValueKind == ValueKind::Image) {
switch (lcArg.mAccQual) {
case AccessQualifier::ReadOnly:
return ROC_ACCESS_TYPE_RO;
case AccessQualifier::WriteOnly:
return ROC_ACCESS_TYPE_WO;
case AccessQualifier::ReadWrite:
default:
return ROC_ACCESS_TYPE_RW;
}
}
return ROC_ACCESS_TYPE_NONE;
}
#endif // defined(WITH_LIGHTNING_COMPILER)
static inline ROC_ACCESS_TYPE GetKernelArgAccessType(const aclArgData* argInfo) {
aclAccessType accessType;
if (argInfo->type == ARG_TYPE_POINTER) {
accessType = argInfo->arg.pointer.type;
} else if (argInfo->type == ARG_TYPE_IMAGE) {
accessType = argInfo->arg.image.type;
} else {
return ROC_ACCESS_TYPE_NONE;
}
if (accessType == ACCESS_TYPE_RO) {
return ROC_ACCESS_TYPE_RO;
} else if (accessType == ACCESS_TYPE_WO) {
return ROC_ACCESS_TYPE_WO;
}
return ROC_ACCESS_TYPE_RW;
}
#if defined(WITH_LIGHTNING_COMPILER)
static inline ROC_ADDRESS_QUALIFIER GetKernelAddrQual(const KernelArgMD& lcArg) {
if (lcArg.mValueKind == ValueKind::DynamicSharedPointer) {
return ROC_ADDRESS_LOCAL;
} else if (lcArg.mValueKind == ValueKind::GlobalBuffer) {
if (lcArg.mAddrSpaceQual == AddressSpaceQualifier::Global || lcArg.mAddrSpaceQual == AddressSpaceQualifier::Generic) {
return ROC_ADDRESS_GLOBAL;
} else if (lcArg.mAddrSpaceQual == AddressSpaceQualifier::Constant) {
return ROC_ADDRESS_CONSTANT;
}
LogError("Unsupported address type");
return ROC_ADDRESS_ERROR;
} else if (lcArg.mValueKind == ValueKind::Image ||
lcArg.mValueKind == ValueKind::Sampler ||
lcArg.mValueKind == ValueKind::Pipe) {
return ROC_ADDRESS_GLOBAL;
}
return ROC_ADDRESS_ERROR;
}
#endif // defined(WITH_LIGHTNING_COMPILER)
static inline ROC_ADDRESS_QUALIFIER GetKernelAddrQual(const aclArgData* argInfo) {
if (argInfo->type == ARG_TYPE_POINTER) {
switch (argInfo->arg.pointer.memory) {
case PTR_MT_CONSTANT_EMU:
case PTR_MT_UAV_CONSTANT:
case PTR_MT_CONSTANT:
return ROC_ADDRESS_CONSTANT;
case PTR_MT_UAV:
case PTR_MT_GLOBAL:
return ROC_ADDRESS_GLOBAL;
case PTR_MT_LDS_EMU:
case PTR_MT_LDS:
return ROC_ADDRESS_LOCAL;
case PTR_MT_ERROR:
default:
LogError("Unsupported address type");
return ROC_ADDRESS_ERROR;
}
} else if ((argInfo->type == ARG_TYPE_IMAGE) || (argInfo->type == ARG_TYPE_SAMPLER)) {
return ROC_ADDRESS_GLOBAL;
}
return ROC_ADDRESS_ERROR;
}
inline static uint32_t GetOclArgumentType(const HSAILKernel::Argument* arg) {
switch (arg->type_){
case ROC_ARGTYPE_HIDDEN_GLOBAL_OFFSET_X:
return amd::KernelParameterDescriptor::HiddenGlobalOffsetX;
case ROC_ARGTYPE_HIDDEN_GLOBAL_OFFSET_Y:
return amd::KernelParameterDescriptor::HiddenGlobalOffsetY;
case ROC_ARGTYPE_HIDDEN_GLOBAL_OFFSET_Z:
return amd::KernelParameterDescriptor::HiddenGlobalOffsetZ;
case ROC_ARGTYPE_HIDDEN_PRINTF_BUFFER:
return amd::KernelParameterDescriptor::HiddenPrintfBuffer;
case ROC_ARGTYPE_HIDDEN_DEFAULT_QUEUE:
return amd::KernelParameterDescriptor::HiddenDefaultQueue;
case ROC_ARGTYPE_HIDDEN_COMPLETION_ACTION:
return amd::KernelParameterDescriptor::HiddenCompletionAction;
case ROC_ARGTYPE_POINTER:
return amd::KernelParameterDescriptor::MemoryObject;
case ROC_ARGTYPE_IMAGE:
return amd::KernelParameterDescriptor::ImageObject;
case ROC_ARGTYPE_REFERENCE:
return amd::KernelParameterDescriptor::ReferenceObject;
case ROC_ARGTYPE_VALUE:
return amd::KernelParameterDescriptor::ValueObject;
case ROC_ARGTYPE_SAMPLER:
return amd::KernelParameterDescriptor::SamplerObject;
case ROC_ARGTYPE_QUEUE:
return amd::KernelParameterDescriptor::QueueObject;
default:
return amd::KernelParameterDescriptor::HiddenNone;
}
}
#if defined(WITH_LIGHTNING_COMPILER)
static inline ROC_DATA_TYPE GetKernelDataType(const KernelArgMD& lcArg) {
aclArgDataType dataType;
if (lcArg.mValueKind != ValueKind::ByValue) {
return ROC_DATATYPE_ERROR;
}
switch (lcArg.mValueType) {
case ValueType::I8:
return ROC_DATATYPE_S8;
case ValueType::I16:
return ROC_DATATYPE_S16;
case ValueType::I32:
return ROC_DATATYPE_S32;
case ValueType::I64:
return ROC_DATATYPE_S64;
case ValueType::U8:
return ROC_DATATYPE_U8;
case ValueType::U16:
return ROC_DATATYPE_U16;
case ValueType::U32:
return ROC_DATATYPE_U32;
case ValueType::U64:
return ROC_DATATYPE_U64;
case ValueType::F16:
return ROC_DATATYPE_F16;
case ValueType::F32:
return ROC_DATATYPE_F32;
case ValueType::F64:
return ROC_DATATYPE_F64;
case ValueType::Struct:
return ROC_DATATYPE_STRUCT;
default:
return ROC_DATATYPE_ERROR;
}
}
#endif // defined(WITH_LIGHTNING_COMPILER)
/* f16 returns f32 - workaround due to comp lib */
static inline ROC_DATA_TYPE GetKernelDataType(const aclArgData* argInfo) {
aclArgDataType dataType;
if (argInfo->type == ARG_TYPE_POINTER) {
dataType = argInfo->arg.pointer.data;
} else if (argInfo->type == ARG_TYPE_VALUE) {
dataType = argInfo->arg.value.data;
} else {
return ROC_DATATYPE_ERROR;
}
switch (dataType) {
case DATATYPE_i1:
return ROC_DATATYPE_B1;
case DATATYPE_i8:
return ROC_DATATYPE_S8;
case DATATYPE_i16:
return ROC_DATATYPE_S16;
case DATATYPE_i32:
return ROC_DATATYPE_S32;
case DATATYPE_i64:
return ROC_DATATYPE_S64;
case DATATYPE_u8:
return ROC_DATATYPE_U8;
case DATATYPE_u16:
return ROC_DATATYPE_U16;
case DATATYPE_u32:
return ROC_DATATYPE_U32;
case DATATYPE_u64:
return ROC_DATATYPE_U64;
case DATATYPE_f16:
return ROC_DATATYPE_F32;
case DATATYPE_f32:
return ROC_DATATYPE_F32;
case DATATYPE_f64:
return ROC_DATATYPE_F64;
case DATATYPE_struct:
return ROC_DATATYPE_STRUCT;
case DATATYPE_opaque:
return ROC_DATATYPE_OPAQUE;
case DATATYPE_ERROR:
default:
return ROC_DATATYPE_ERROR;
}
}
static inline int GetKernelArgSize(const aclArgData* argInfo) {
switch (argInfo->type) {
case ARG_TYPE_POINTER:
return sizeof(void*);
case ARG_TYPE_VALUE:
switch (argInfo->arg.value.data) {
case DATATYPE_i8:
case DATATYPE_u8:
case DATATYPE_struct:
return 1 * argInfo->arg.value.numElements;
case DATATYPE_u16:
case DATATYPE_i16:
case DATATYPE_f16:
return 2 * argInfo->arg.value.numElements;
case DATATYPE_u32:
case DATATYPE_i32:
case DATATYPE_f32:
return 4 * argInfo->arg.value.numElements;
case DATATYPE_i64:
case DATATYPE_u64:
case DATATYPE_f64:
return 8 * argInfo->arg.value.numElements;
case DATATYPE_ERROR:
default:
return -1;
}
case ARG_TYPE_IMAGE:
return sizeof(cl_mem);
case ARG_TYPE_SAMPLER:
return sizeof(cl_sampler);
default:
return -1;
}
}
static inline clk_value_type_t GetOclType(const Kernel::Argument* arg) {
static const clk_value_type_t ClkValueMapType[6][6] = {
{T_CHAR, T_CHAR2, T_CHAR3, T_CHAR4, T_CHAR8, T_CHAR16},
{T_SHORT, T_SHORT2, T_SHORT3, T_SHORT4, T_SHORT8, T_SHORT16},
{T_INT, T_INT2, T_INT3, T_INT4, T_INT8, T_INT16},
{T_LONG, T_LONG2, T_LONG3, T_LONG4, T_LONG8, T_LONG16},
{T_FLOAT, T_FLOAT2, T_FLOAT3, T_FLOAT4, T_FLOAT8, T_FLOAT16},
{T_DOUBLE, T_DOUBLE2, T_DOUBLE3, T_DOUBLE4, T_DOUBLE8, T_DOUBLE16},
};
uint sizeType;
uint numElements;
if (arg->type_ == ROC_ARGTYPE_POINTER || arg->type_ == ROC_ARGTYPE_IMAGE) {
return T_POINTER;
} else if (arg->type_ == ROC_ARGTYPE_VALUE || arg->type_ == ROC_ARGTYPE_REFERENCE) {
switch (arg->dataType_) {
case ROC_DATATYPE_S8:
case ROC_DATATYPE_U8:
sizeType = 0;
numElements = arg->size_;
break;
case ROC_DATATYPE_S16:
case ROC_DATATYPE_U16:
sizeType = 1;
numElements = arg->size_ / 2;
break;
case ROC_DATATYPE_S32:
case ROC_DATATYPE_U32:
sizeType = 2;
numElements = arg->size_ / 4;
break;
case ROC_DATATYPE_S64:
case ROC_DATATYPE_U64:
sizeType = 3;
numElements = arg->size_ / 8;
break;
case ROC_DATATYPE_F16:
sizeType = 4;
numElements = arg->size_ / 2;
break;
case ROC_DATATYPE_F32:
sizeType = 4;
numElements = arg->size_ / 4;
break;
case ROC_DATATYPE_F64:
sizeType = 5;
numElements = arg->size_ / 8;
break;
default:
return T_VOID;
}
switch (numElements) {
case 1:
return ClkValueMapType[sizeType][0];
case 2:
return ClkValueMapType[sizeType][1];
case 3:
return ClkValueMapType[sizeType][2];
case 4:
return ClkValueMapType[sizeType][3];
case 8:
return ClkValueMapType[sizeType][4];
case 16:
return ClkValueMapType[sizeType][5];
default:
return T_VOID;
}
} else if (arg->type_ == ROC_ARGTYPE_SAMPLER) {
return T_SAMPLER;
} else if (arg->type_ == ROC_ARGTYPE_QUEUE) {
return T_QUEUE;
} else {
return T_VOID;
}
}
static inline cl_kernel_arg_address_qualifier GetOclAddrQual(const Kernel::Argument* arg) {
if (arg->type_ == ROC_ARGTYPE_POINTER) {
switch (arg->addrQual_) {
case ROC_ADDRESS_GLOBAL:
return CL_KERNEL_ARG_ADDRESS_GLOBAL;
case ROC_ADDRESS_CONSTANT:
return CL_KERNEL_ARG_ADDRESS_CONSTANT;
case ROC_ADDRESS_LOCAL:
return CL_KERNEL_ARG_ADDRESS_LOCAL;
default:
return CL_KERNEL_ARG_ADDRESS_PRIVATE;
}
} else if (arg->type_ == ROC_ARGTYPE_IMAGE) {
return CL_KERNEL_ARG_ADDRESS_GLOBAL;
}
// default for all other cases
return CL_KERNEL_ARG_ADDRESS_PRIVATE;
}
static inline cl_kernel_arg_access_qualifier GetOclAccessQual(const Kernel::Argument* arg) {
if (arg->type_ == ROC_ARGTYPE_IMAGE) {
switch (arg->access_) {
case ROC_ACCESS_TYPE_RO:
return CL_KERNEL_ARG_ACCESS_READ_ONLY;
case ROC_ACCESS_TYPE_WO:
return CL_KERNEL_ARG_ACCESS_WRITE_ONLY;
case ROC_ACCESS_TYPE_RW:
return CL_KERNEL_ARG_ACCESS_READ_WRITE;
default:
return CL_KERNEL_ARG_ACCESS_NONE;
}
}
return CL_KERNEL_ARG_ACCESS_NONE;
}
#if defined(WITH_LIGHTNING_COMPILER)
static inline cl_kernel_arg_type_qualifier GetOclTypeQual(const KernelArgMD& lcArg) {
cl_kernel_arg_type_qualifier rv = CL_KERNEL_ARG_TYPE_NONE;
if (lcArg.mValueKind == ValueKind::GlobalBuffer ||
lcArg.mValueKind == ValueKind::DynamicSharedPointer) {
if (lcArg.mIsVolatile) {
rv |= CL_KERNEL_ARG_TYPE_VOLATILE;
}
if (lcArg.mIsRestrict) {
rv |= CL_KERNEL_ARG_TYPE_RESTRICT;
}
if (lcArg.mIsConst) {
rv |= CL_KERNEL_ARG_TYPE_CONST;
}
}
else if (lcArg.mIsPipe) {
assert(lcArg.mValueKind == ValueKind::Pipe);
rv |= CL_KERNEL_ARG_TYPE_PIPE;
}
return rv;
}
#endif // defined(WITH_LIGHTNING_COMPILER)
static inline cl_kernel_arg_type_qualifier GetOclTypeQual(const aclArgData* argInfo) {
cl_kernel_arg_type_qualifier rv = CL_KERNEL_ARG_TYPE_NONE;
if (argInfo->type == ARG_TYPE_POINTER) {
if (argInfo->arg.pointer.isVolatile) {
rv |= CL_KERNEL_ARG_TYPE_VOLATILE;
}
if (argInfo->arg.pointer.isRestrict) {
rv |= CL_KERNEL_ARG_TYPE_RESTRICT;
}
if (argInfo->isConst) {
rv |= CL_KERNEL_ARG_TYPE_CONST;
}
switch (argInfo->arg.pointer.memory) {
case PTR_MT_CONSTANT:
case PTR_MT_UAV_CONSTANT:
case PTR_MT_CONSTANT_EMU:
rv |= CL_KERNEL_ARG_TYPE_CONST;
break;
default:
break;
}
}
return rv;
}
#if defined(WITH_COMPILER_LIB)
void HSAILKernel::initArguments(const aclArgData* aclArg) {
device::Kernel::parameters_t params;
device::Kernel::parameters_t hiddenParams;
size_t offsetStruct = KernargSegmentByteSize();
// Iterate through the arguments and insert into parameterList
for (size_t offset = 0; aclArg->struct_size != 0; aclArg++) {
// Initialize HSAIL kernel argument
Kernel::Argument* arg = new Kernel::Argument;
arg->name_ = aclArg->argStr;
arg->typeName_ = aclArg->typeStr;
arg->size_ = GetKernelArgSize(aclArg);
arg->type_ = GetKernelArgType(aclArg);
arg->addrQual_ = GetKernelAddrQual(aclArg);
arg->dataType_ = GetKernelDataType(aclArg);
arg->alignment_ = GetKernelArgAlignment(aclArg);
arg->access_ = GetKernelArgAccessType(aclArg);
arg->pointeeAlignment_ = GetKernelArgPointeeAlignment(aclArg);
bool isHidden = arg->type_ == ROC_ARGTYPE_HIDDEN_GLOBAL_OFFSET_X ||
arg->type_ == ROC_ARGTYPE_HIDDEN_GLOBAL_OFFSET_Y ||
arg->type_ == ROC_ARGTYPE_HIDDEN_GLOBAL_OFFSET_Z ||
arg->type_ == ROC_ARGTYPE_HIDDEN_PRINTF_BUFFER ||
arg->type_ == ROC_ARGTYPE_HIDDEN_DEFAULT_QUEUE ||
arg->type_ == ROC_ARGTYPE_HIDDEN_COMPLETION_ACTION || arg->type_ == ROC_ARGTYPE_HIDDEN_NONE;
arg->index_ = isHidden ? uint(-1) : params.size();
hsailArgList_.push_back(arg);
amd::KernelParameterDescriptor desc;
// Allocate the hidden arguments, but abstraction layer will skip them
if (isHidden) {
offset = amd::alignUp(offset, arg->alignment_);
desc.offset_ = offset;
desc.size_ = arg->size_;
offset += arg->size_;
desc.info_.oclObject_ = GetOclArgumentType(arg);
hiddenParams.push_back(desc);
continue;
}
desc.name_ = arg->name_.c_str();
desc.type_ = GetOclType(arg);
desc.addressQualifier_ = GetOclAddrQual(arg);
desc.accessQualifier_ = GetOclAccessQual(arg);
desc.typeQualifier_ = GetOclTypeQual(aclArg);
desc.typeName_ = arg->typeName_.c_str();
desc.info_.oclObject_ = GetOclArgumentType(arg);
desc.info_.arrayIndex_ = arg->pointeeAlignment_;
// set image related flags
if (arg->type_ == ROC_ARGTYPE_IMAGE) {
flags_.imageEnable_ = true;
if (desc.accessQualifier_ == CL_KERNEL_ARG_ACCESS_WRITE_ONLY ||
desc.accessQualifier_ == CL_KERNEL_ARG_ACCESS_READ_WRITE) {
flags_.imageWrite_ = true;
}
}
desc.size_ = arg->size_;
// Make offset alignment to match CPU metadata, since
// in multidevice config abstraction layer has a single signature
// and CPU sends the parameters as they are allocated in memory
size_t size = desc.size_;
// Check if HSAIL expects data by reference and allocate it behind
if (arg->type_ == ROC_ARGTYPE_REFERENCE) {
desc.offset_ = offsetStruct;
// Align the offset reference
offset = amd::alignUp(offset, sizeof(size_t));
patchReferences_.insert({desc.offset_, offset});
offsetStruct += size;
// Adjust the offset of arguments
offset += sizeof(size_t);
}
else if ((desc.info_.oclObject_ == amd::KernelParameterDescriptor::ImageObject) ||
(desc.info_.oclObject_ == amd::KernelParameterDescriptor::SamplerObject) ||
(desc.info_.oclObject_ == amd::KernelParameterDescriptor::QueueObject)) {
// These objects have forced data size to uint64_t
offset = amd::alignUp(offset, sizeof(uint64_t));
desc.offset_ = offset;
offset += sizeof(uint64_t);
} else {
offset = amd::alignUp(offset, arg->alignment_);
desc.offset_ = offset;
offset += size;
}
// Update read only flag
desc.info_.readOnly_ = (arg->access_ == ROC_ACCESS_TYPE_RO) ? true : false;
params.push_back(desc);
}
// Save the number of OCL arguments
uint32_t numParams = params.size();
// Append the hidden arguments to the OCL arguments
params.insert(params.end(), hiddenParams.begin(), hiddenParams.end());
createSignature(params, numParams, amd::KernelSignature::ABIVersion_1);
}
#endif // defined(WITH_COMPILER_LIB)
#if defined(WITH_LIGHTNING_COMPILER)
void LightningKernel::initArguments(const KernelMD& kernelMD) {
device::Kernel::parameters_t params;
device::Kernel::parameters_t hiddenParams;
size_t offsetStruct = KernargSegmentByteSize();
size_t offset = 0;
for (size_t i = 0; i < kernelMD.mArgs.size(); ++i) {
const KernelArgMD& lcArg = kernelMD.mArgs[i];
// Initialize HSAIL kernel argument
Kernel::Argument* arg = new Kernel::Argument;
arg->name_ = lcArg.mName;
arg->typeName_ = lcArg.mTypeName;
arg->size_ = lcArg.mSize;
arg->type_ = GetKernelArgType(lcArg);
arg->addrQual_ = GetKernelAddrQual(lcArg);
arg->dataType_ = GetKernelDataType(lcArg);
arg->alignment_ = GetKernelArgAlignment(lcArg);
arg->access_ = GetKernelArgAccessType(lcArg);
arg->pointeeAlignment_ = GetKernelArgPointeeAlignment(lcArg);
bool isHidden = arg->type_ == ROC_ARGTYPE_HIDDEN_GLOBAL_OFFSET_X ||
arg->type_ == ROC_ARGTYPE_HIDDEN_GLOBAL_OFFSET_Y ||
arg->type_ == ROC_ARGTYPE_HIDDEN_GLOBAL_OFFSET_Z ||
arg->type_ == ROC_ARGTYPE_HIDDEN_PRINTF_BUFFER ||
arg->type_ == ROC_ARGTYPE_HIDDEN_DEFAULT_QUEUE ||
arg->type_ == ROC_ARGTYPE_HIDDEN_COMPLETION_ACTION || arg->type_ == ROC_ARGTYPE_HIDDEN_NONE;
arg->index_ = isHidden ? uint(-1) : params.size();
hsailArgList_.push_back(arg);
// Initialize Device kernel parameters
amd::KernelParameterDescriptor desc;
if (isHidden) {
offset = amd::alignUp(offset, arg->alignment_);
desc.offset_ = offset;
desc.size_ = arg->size_;
offset += arg->size_;
desc.info_.oclObject_ = GetOclArgumentType(arg);
hiddenParams.push_back(desc);
continue;
}
desc.name_ = lcArg.mName.c_str();
desc.type_ = GetOclType(arg);
desc.addressQualifier_ = GetOclAddrQual(arg);
desc.accessQualifier_ = GetOclAccessQual(arg);
desc.typeQualifier_ = GetOclTypeQual(lcArg);
desc.typeName_ = lcArg.mTypeName.c_str();
desc.info_.oclObject_ = GetOclArgumentType(arg);
desc.info_.arrayIndex_ = arg->pointeeAlignment_;
// set image related flags
if (arg->type_ == ROC_ARGTYPE_IMAGE) {
flags_.imageEnable_ = true;
if (desc.accessQualifier_ == CL_KERNEL_ARG_ACCESS_WRITE_ONLY ||
desc.accessQualifier_ == CL_KERNEL_ARG_ACCESS_READ_WRITE) {
flags_.imageWrite_ = true;
}
}
desc.size_ = arg->size_;
// Make offset alignment to match CPU metadata, since
// in multidevice config abstraction layer has a single signature
// and CPU sends the parameters as they are allocated in memory
size_t size = desc.size_;
// Check if HSAIL expects data by reference and allocate it behind
if (arg->type_ == ROC_ARGTYPE_REFERENCE) {
desc.offset_ = offsetStruct;
// Align the offset reference
offset = amd::alignUp(offset, sizeof(size_t));
patchReferences_.insert({desc.offset_, offset});
offsetStruct += size;
// Adjust the offset of arguments
offset += sizeof(size_t);
}
else if ((desc.info_.oclObject_ == amd::KernelParameterDescriptor::ImageObject) ||
(desc.info_.oclObject_ == amd::KernelParameterDescriptor::SamplerObject) ||
(desc.info_.oclObject_ == amd::KernelParameterDescriptor::QueueObject)) {
// These objects have forced data size to uint64_t
offset = amd::alignUp(offset, sizeof(uint64_t));
desc.offset_ = offset;
offset += sizeof(uint64_t);
} else {
offset = amd::alignUp(offset, arg->alignment_);
desc.offset_ = offset;
offset += size;
}
// Update read only flag
desc.info_.readOnly_ = (arg->access_ == ROC_ACCESS_TYPE_RO) ? true : false;
params.push_back(desc);
}
// Save the number of OCL arguments
uint32_t numParams = params.size();
// Append the hidden arguments to the OCL arguments
params.insert(params.end(), hiddenParams.begin(), hiddenParams.end());
createSignature(params, numParams, amd::KernelSignature::ABIVersion_1);
}
#endif // defined(WITH_LIGHTNING_COMPILER)
Kernel::Kernel(std::string name, Program* prog, const uint64_t& kernelCodeHandle,
const uint32_t workgroupGroupSegmentByteSize,
const uint32_t workitemPrivateSegmentByteSize, const uint32_t kernargSegmentByteSize,
@@ -787,7 +44,7 @@ bool LightningKernel::init() {
if (kernelMD == nullptr) {
return false;
}
initArguments(*kernelMD);
InitParameters(*kernelMD, KernargSegmentByteSize());
// Set the workgroup information for the kernel
workGroupInfo_.availableLDSSize_ = program_->dev().info().localMemSizePerCU_;
@@ -907,7 +164,7 @@ bool HSAILKernel::init() {
}
// Set the argList
initArguments((const aclArgData*)argList.get());
InitParameters((const aclArgData*)argList.get(), KernargSegmentByteSize());
// Set the workgroup information for the kernel
memset(&workGroupInfo_, 0, sizeof(workGroupInfo_));
@@ -1151,11 +408,6 @@ void HSAILKernel::initPrintf(const aclPrintfFmt* aclPrintf) {
#endif // defined(WITH_COMPILER_LIB)
Kernel::~Kernel() {
while (!hsailArgList_.empty()) {
Argument* kernelArgPointer = hsailArgList_.back();
delete kernelArgPointer;
hsailArgList_.pop_back();
}
}
} // namespace roc