AI/rocm-systems
2
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

P4 to Git Change 1329974 by lmoriche@lmoriche_opencl_dev on 2016/10/21 13:09:44

Browse Source 
SWDEV-105604 - OpenCL program manager for LC on PAL (Initial check-in)
	- Created LightningProgram and LightningKernel classes
	- Implemented LightningProgram::compileImpl and LightningProgram::linkImpl using LC
	- Implemented LightningKernel::init (to set up args using the LC metadata)
	Tests: Passes clinfo and HelloWorld.
	Pre-checkin: http://ocltc.amd.com:8111/viewModification.html?modId=77957&personal=true&buildTypeId=&tab=vcsModificationBuilds&show_all_builds=true

Affected files ...

... //depot/stg/opencl/drivers/opencl/api/opencl/amdocl/build/Makefile.api#141 edit
... //depot/stg/opencl/drivers/opencl/compiler/Makefile#67 edit
... //depot/stg/opencl/drivers/opencl/compiler/sclibdefs.opencl#11 edit
... //depot/stg/opencl/drivers/opencl/library/build/Makefile.library#57 edit
... //depot/stg/opencl/drivers/opencl/make/llvm.git/lib/Target/Makefile#2 edit
... //depot/stg/opencl/drivers/opencl/make/llvm.git/llvmdefs#3 edit
... //depot/stg/opencl/drivers/opencl/make/llvm.git/llvmlibs#9 edit
... //depot/stg/opencl/drivers/opencl/runtime/device/pal/build/Makefile.pal#7 edit
... //depot/stg/opencl/drivers/opencl/runtime/device/pal/palcompiler.cpp#4 edit
... //depot/stg/opencl/drivers/opencl/runtime/device/pal/paldefs.hpp#13 edit
... //depot/stg/opencl/drivers/opencl/runtime/device/pal/paldevice.cpp#26 edit
... //depot/stg/opencl/drivers/opencl/runtime/device/pal/paldevice.hpp#10 edit
... //depot/stg/opencl/drivers/opencl/runtime/device/pal/palkernel.cpp#10 edit
... //depot/stg/opencl/drivers/opencl/runtime/device/pal/palkernel.hpp#5 edit
... //depot/stg/opencl/drivers/opencl/runtime/device/pal/palprogram.cpp#10 edit
... //depot/stg/opencl/drivers/opencl/runtime/device/pal/palprogram.hpp#8 edit


[ROCm/clr commit: cd17800734]
This commit is contained in:
foreman
2016-10-21 13:18:35 -04:00
parent ea8b62527f
commit 2576f51460
8 changed files with 1355 additions and 52 deletions
Download Patch File Download Diff File Expand all files Collapse all files
projects/clr/rocclr/runtime/device/pal/palkernel.cpp
+527 -2
View File
@@ -11,6 +11,10 @@
#include "acl.h"
#if defined(WITH_LIGHTNING_COMPILER)
#include "libamdhsacode/amdgpu_metadata.hpp"
#endif // defined(WITH_LIGHTNING_COMPILER)
#include <string>
#include <memory>
#include <fstream>
@@ -623,6 +627,9 @@ HSAILKernel::~HSAILKernel()
bool
HSAILKernel::init(amd::hsa::loader::Symbol *sym, bool finalize)
{
#if defined(WITH_LIGHTNING_COMPILER)
assert(!"Should not reach here");
#else // !defined(WITH_LIGHTNING_COMPILER)
if (extraArgumentsNum_ > MaxExtraArgumentsNum) {
LogError("Failed to initialize kernel: extra arguments number is bigger than is supported");
return false;
@@ -789,7 +796,7 @@ HSAILKernel::init(amd::hsa::loader::Symbol *sym, bool finalize)
delete[] VecTypeHint;
}
#endif // !defined(WITH_LIGHTNING_COMPILER)
return true;
}
@@ -1011,7 +1018,8 @@ HSAILKernel::loadArguments(
switch (arg->type_) {
case HSAIL_ARGTYPE_POINTER:
// If it is a global pointer
if (arg->addrQual_ == HSAIL_ADDRESS_GLOBAL) {
if (arg->addrQual_ == HSAIL_ADDRESS_GLOBAL
|| arg->addrQual_ == HSAIL_ADDRESS_CONSTANT) {
Memory* gpuMem = nullptr;
amd::Memory* mem = nullptr;
@@ -1183,6 +1191,14 @@ HSAILKernel::loadArguments(
return nullptr;
}
#if defined(WITH_LIGHTNING_COMPILER)
//!!!!!FIXME_lmoriche: fix the hidden args
size_t zero;
WriteAqlArg(&aqlArgBuf, &zero, sizeof(zero));
WriteAqlArg(&aqlArgBuf, &zero, sizeof(zero));
WriteAqlArg(&aqlArgBuf, &zero, sizeof(zero));
#endif // defined(WITH_LIGHTNING_COMPILER)
// HSAIL kernarg segment size is rounded up to multiple of 16.
aqlArgBuf = amd::alignUp(aqlArgBuf, 16);
assert((aqlArgBuf == (gpu.cb(0)->sysMemCopy() + argsBufferSize())) &&
@@ -1238,4 +1254,513 @@ HSAILKernel::loadArguments(
return hsaDisp;
}
#if defined(WITH_LIGHTNING_COMPILER)
const LightningProgram&
LightningKernel::prog() const
{
return reinterpret_cast<const LightningProgram&>(prog_);
}
void
LightningKernel::initPrintf(const std::vector<std::string>& printfInfoStrings)
{
for (auto str : printfInfoStrings) {
std::vector<std::string> tokens;
size_t end, pos = 0;
do {
end = str.find_first_of(':', pos);
tokens.push_back(str.substr(pos, end-pos));
pos = end + 1;
} while (end != std::string::npos);
if (tokens.size() < 2) {
LogPrintfWarning("Invalid PrintInfo string: \"%s\"", str.c_str());
continue;
}
pos = 0;
size_t printfInfoID = std::stoi(tokens[pos++]);
if (printf_.size() <= printfInfoID) {
printf_.resize(printfInfoID + 1);
}
PrintfInfo& info = printf_[printfInfoID];
size_t numSizes = std::stoi(tokens[pos++]);
end = pos + numSizes;
// ensure that we have the correct number of tokens
if (tokens.size() < end + 1/*last token is the fmtString*/) {
LogPrintfWarning("Invalid PrintInfo string: \"%s\"", str.c_str());
continue;
}
// push the argument sizes
while (pos < end) {
info.arguments_.push_back(std::stoi(tokens[pos++]));
}
// FIXME: We should not need this! [
std::string& fmt = tokens[pos];
bool need_nl = true;
for (pos = 0; pos < fmt.size(); ++pos) {
char symbol = fmt[pos];
need_nl = true;
if (symbol == '\\') {
switch (fmt[pos+1]) {
case 'a':
pos++;
symbol = '\a';
break;
case 'b':
pos++;
symbol = '\b';
break;
case 'f':
pos++;
symbol = '\f';
break;
case 'n':
pos++;
symbol = '\n';
need_nl = false;
break;
case 'r':
pos++;
symbol = '\r';
break;
case 'v':
pos++;
symbol = '\v';
break;
case '7':
if (fmt[pos+2] == '2') {
pos += 2;
symbol = '\72';
}
break;
default:
break;
}
}
info.fmtString_.push_back(symbol);
}
if (need_nl) {
info.fmtString_ += "\n";
}
// ]
}
}
static inline HSAIL_ARG_TYPE
GetKernelArgType(const amd::hsa::code::KernelArg::Metadata& lcArg)
{
switch (lcArg.Kind()) {
case AMDGPU::RuntimeMD::KernelArg::GlobalBuffer:
case AMDGPU::RuntimeMD::KernelArg::DynamicSharedPointer:
return HSAIL_ARGTYPE_POINTER;
case AMDGPU::RuntimeMD::KernelArg::ByValue:
return HSAIL_ARGTYPE_VALUE;
case AMDGPU::RuntimeMD::KernelArg::Image:
return HSAIL_ARGTYPE_IMAGE;
case AMDGPU::RuntimeMD::KernelArg::Sampler:
return HSAIL_ARGTYPE_SAMPLER;
case AMDGPU::RuntimeMD::KernelArg::HiddenGlobalOffsetX:
return HSAIL_ARGTYPE_HIDDEN_GLOBAL_OFFSET_X;
case AMDGPU::RuntimeMD::KernelArg::HiddenGlobalOffsetY:
return HSAIL_ARGTYPE_HIDDEN_GLOBAL_OFFSET_Y;
case AMDGPU::RuntimeMD::KernelArg::HiddenGlobalOffsetZ:
return HSAIL_ARGTYPE_HIDDEN_GLOBAL_OFFSET_Z;
case AMDGPU::RuntimeMD::KernelArg::HiddenPrintfBuffer:
return HSAIL_ARGTYPE_HIDDEN_PRINTF_BUFFER;
case AMDGPU::RuntimeMD::KernelArg::HiddenDefaultQueue:
return HSAIL_ARGTYPE_HIDDEN_DEFAULT_QUEUE;
case AMDGPU::RuntimeMD::KernelArg::HiddenCompletionAction:
return HSAIL_ARGTYPE_HIDDEN_COMPLETION_ACTION;
case AMDGPU::RuntimeMD::KernelArg::HiddenNone:
return HSAIL_ARGTYPE_HIDDEN_NONE;
default:
return HSAIL_ARGTYPE_ERROR;
}
}
static inline size_t
GetKernelArgAlignment(const amd::hsa::code::KernelArg::Metadata& lcArg)
{
return lcArg.Align();
}
static inline size_t
GetKernelArgPointeeAlignment(const amd::hsa::code::KernelArg::Metadata& lcArg)
{
if (lcArg.Kind() == AMDGPU::RuntimeMD::KernelArg::DynamicSharedPointer) {
uint32_t align = lcArg.PointeeAlign();
if (align == 0) {
LogWarning("Missing DynamicSharedPointer alignment");
align = 128; /* worst case alignment */;
}
return align;
}
return 1;
}
static inline HSAIL_ACCESS_TYPE
GetKernelArgAccessType(const amd::hsa::code::KernelArg::Metadata& lcArg)
{
if (lcArg.Kind() == AMDGPU::RuntimeMD::KernelArg::GlobalBuffer
|| lcArg.Kind() == AMDGPU::RuntimeMD::KernelArg::Image) {
switch (lcArg.AccQual()) {
case AMDGPU::RuntimeMD::KernelArg::ReadOnly:
return HSAIL_ACCESS_TYPE_RO;
case AMDGPU::RuntimeMD::KernelArg::WriteOnly:
return HSAIL_ACCESS_TYPE_WO;
case AMDGPU::RuntimeMD::KernelArg::ReadWrite:
default:
return HSAIL_ACCESS_TYPE_RW;
}
}
return HSAIL_ACCESS_TYPE_NONE;
}
static inline HSAIL_ADDRESS_QUALIFIER
GetKernelAddrQual(const amd::hsa::code::KernelArg::Metadata& lcArg)
{
if (lcArg.Kind() == AMDGPU::RuntimeMD::KernelArg::DynamicSharedPointer) {
return HSAIL_ADDRESS_LOCAL;
}
else if (lcArg.Kind() == AMDGPU::RuntimeMD::KernelArg::GlobalBuffer) {
if (lcArg.AddrQual() == AMDGPU::RuntimeMD::KernelArg::Global) {
return HSAIL_ADDRESS_GLOBAL;
}
else if (lcArg.AddrQual() == AMDGPU::RuntimeMD::KernelArg::Constant) {
return HSAIL_ADDRESS_CONSTANT;
}
LogError("Unsupported address type");
return HSAIL_ADDRESS_ERROR;
}
else if (lcArg.Kind() == AMDGPU::RuntimeMD::KernelArg::Image
|| lcArg.Kind() == AMDGPU::RuntimeMD::KernelArg::Sampler) {
return HSAIL_ADDRESS_GLOBAL;
}
return HSAIL_ADDRESS_ERROR;
}
static inline HSAIL_DATA_TYPE
GetKernelDataType(const amd::hsa::code::KernelArg::Metadata& lcArg)
{
aclArgDataType dataType;
if (lcArg.Kind() != AMDGPU::RuntimeMD::KernelArg::ByValue) {
return HSAIL_DATATYPE_ERROR;
}
switch (lcArg.ValueType()) {
case AMDGPU::RuntimeMD::KernelArg::I8:
return HSAIL_DATATYPE_S8;
case AMDGPU::RuntimeMD::KernelArg::I16:
return HSAIL_DATATYPE_S16;
case AMDGPU::RuntimeMD::KernelArg::I32:
return HSAIL_DATATYPE_S32;
case AMDGPU::RuntimeMD::KernelArg::I64:
return HSAIL_DATATYPE_S64;
case AMDGPU::RuntimeMD::KernelArg::U8:
return HSAIL_DATATYPE_U8;
case AMDGPU::RuntimeMD::KernelArg::U16:
return HSAIL_DATATYPE_U16;
case AMDGPU::RuntimeMD::KernelArg::U32:
return HSAIL_DATATYPE_U32;
case AMDGPU::RuntimeMD::KernelArg::U64:
return HSAIL_DATATYPE_U64;
case AMDGPU::RuntimeMD::KernelArg::F16:
return HSAIL_DATATYPE_F16;
case AMDGPU::RuntimeMD::KernelArg::F32:
return HSAIL_DATATYPE_F32;
case AMDGPU::RuntimeMD::KernelArg::F64:
return HSAIL_DATATYPE_F64;
case AMDGPU::RuntimeMD::KernelArg::Struct:
return HSAIL_DATATYPE_STRUCT;
default:
return HSAIL_DATATYPE_ERROR;
}
}
static inline clk_value_type_t
GetOclType(const HSAILKernel::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_ == HSAIL_ARGTYPE_POINTER || arg->type_ == HSAIL_ARGTYPE_IMAGE) {
return T_POINTER;
}
else if (arg->type_ == HSAIL_ARGTYPE_VALUE
|| arg->type_ == HSAIL_ARGTYPE_REFERENCE) {
switch (arg->dataType_) {
case HSAIL_DATATYPE_S8:
case HSAIL_DATATYPE_U8:
sizeType = 0;
numElements = arg->size_;
break;
case HSAIL_DATATYPE_S16:
case HSAIL_DATATYPE_U16:
sizeType = 1;
numElements = arg->size_ / 2;
break;
case HSAIL_DATATYPE_S32:
case HSAIL_DATATYPE_U32:
sizeType = 2;
numElements = arg->size_ / 4;
break;
case HSAIL_DATATYPE_S64:
case HSAIL_DATATYPE_U64:
sizeType = 3;
numElements = arg->size_ / 8;
break;
case HSAIL_DATATYPE_F16:
sizeType = 4;
numElements = arg->size_ / 2;
break;
case HSAIL_DATATYPE_F32:
sizeType = 4;
numElements = arg->size_ / 4;
break;
case HSAIL_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_ == HSAIL_ARGTYPE_SAMPLER) {
return T_SAMPLER;
}
else {
return T_VOID;
}
}
static inline cl_kernel_arg_address_qualifier
GetOclAddrQual(const HSAILKernel::Argument* arg)
{
if (arg->type_ == HSAIL_ARGTYPE_POINTER) {
switch (arg->addrQual_) {
case HSAIL_ADDRESS_GLOBAL:
return CL_KERNEL_ARG_ADDRESS_GLOBAL;
case HSAIL_ADDRESS_CONSTANT:
return CL_KERNEL_ARG_ADDRESS_CONSTANT;
case HSAIL_ADDRESS_LOCAL:
return CL_KERNEL_ARG_ADDRESS_LOCAL;
default:
return CL_KERNEL_ARG_ADDRESS_PRIVATE;
}
}
else if (arg->type_ == HSAIL_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 HSAILKernel::Argument* arg)
{
if (arg->type_ == HSAIL_ARGTYPE_IMAGE) {
switch (arg->access_) {
case HSAIL_ACCESS_TYPE_RO:
return CL_KERNEL_ARG_ACCESS_READ_ONLY;
case HSAIL_ACCESS_TYPE_WO:
return CL_KERNEL_ARG_ACCESS_WRITE_ONLY;
case HSAIL_ACCESS_TYPE_RW:
return CL_KERNEL_ARG_ACCESS_READ_WRITE;
default:
return CL_KERNEL_ARG_ACCESS_NONE;
}
}
return CL_KERNEL_ARG_ACCESS_NONE;
}
static inline cl_kernel_arg_type_qualifier
GetOclTypeQual(const amd::hsa::code::KernelArg::Metadata& lcArg)
{
cl_kernel_arg_type_qualifier rv = CL_KERNEL_ARG_TYPE_NONE;
if (lcArg.Kind() == AMDGPU::RuntimeMD::KernelArg::GlobalBuffer
|| lcArg.Kind() == AMDGPU::RuntimeMD::KernelArg::DynamicSharedPointer) {
if (lcArg.IsVolatile()) {
rv |= CL_KERNEL_ARG_TYPE_VOLATILE;
}
if (lcArg.IsRestrict()) {
rv |= CL_KERNEL_ARG_TYPE_RESTRICT;
}
if (lcArg.IsConst()) {
rv |= CL_KERNEL_ARG_TYPE_CONST;
}
}
return rv;
}
void
LightningKernel::initArgList(const amd::hsa::code::Kernel::Metadata& kernelMD)
{
device::Kernel::parameters_t params;
size_t offset = 0;
for (size_t i = 0; i < kernelMD.KernelArgCount(); ++i) {
const amd::hsa::code::KernelArg::Metadata& lcArg =
kernelMD.GetKernelArgMetadata(i);
// Initialize HSAIL kernel argument
auto arg = new HSAILKernel::Argument;
arg->name_ = lcArg.Name();
arg->typeName_ = lcArg.TypeName();
arg->size_ = lcArg.Size();
arg->type_ = GetKernelArgType(lcArg);
arg->addrQual_ = GetKernelAddrQual(lcArg);
arg->dataType_ = GetKernelDataType(lcArg);
arg->alignment_ = GetKernelArgAlignment(lcArg);
arg->access_ = GetKernelArgAccessType(lcArg);
arg->numElem_ = 1;
arg->pointeeAlignment_ = GetKernelArgPointeeAlignment(lcArg);
bool isHidden = arg->type_ == HSAIL_ARGTYPE_HIDDEN_GLOBAL_OFFSET_X
|| arg->type_ == HSAIL_ARGTYPE_HIDDEN_GLOBAL_OFFSET_Y
|| arg->type_ == HSAIL_ARGTYPE_HIDDEN_GLOBAL_OFFSET_Z
|| arg->type_ == HSAIL_ARGTYPE_HIDDEN_PRINTF_BUFFER
|| arg->type_ == HSAIL_ARGTYPE_HIDDEN_DEFAULT_QUEUE
|| arg->type_ == HSAIL_ARGTYPE_HIDDEN_COMPLETION_ACTION
|| arg->type_ == HSAIL_ARGTYPE_HIDDEN_NONE;
arg->index_ = isHidden ? uint(-1) : params.size();
arguments_.push_back(arg);
if (isHidden) {
continue;
}
// Initialize Device kernel parameters
amd::KernelParameterDescriptor desc;
desc.name_ = lcArg.Name().c_str();
desc.type_ = GetOclType(arg);
desc.addressQualifier_ = GetOclAddrQual(arg);
desc.accessQualifier_ = GetOclAccessQual(arg);
desc.typeQualifier_ = GetOclTypeQual(lcArg);
desc.typeName_ = lcArg.TypeName().c_str();
// Make a check if it is local or global
if (desc.addressQualifier_ == CL_KERNEL_ARG_ADDRESS_LOCAL) {
desc.size_ = 0;
}
else {
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_;
if (size == 0) {
// Local memory for CPU
size = sizeof(cl_mem);
}
offset = (size_t) amd::alignUp(offset, std::min(size, size_t(16)));
desc.offset_ = offset;
offset += amd::alignUp(size, sizeof(uint32_t));
params.push_back(desc);
}
createSignature(params);
}
bool
LightningKernel::init(amd::hsa::loader::Symbol* symbol)
{
flags_.internalKernel_ = (compileOptions_.find("-cl-internal-kernel") !=
std::string::npos) ? true: false;
aqlCreateHWInfo(symbol);
const amd::hsa::code::Program::Metadata* runtimeMD = prog().metadata();
if (!runtimeMD) {
return false;
}
const amd::hsa::code::Kernel::Metadata& kernelMD =
runtimeMD->GetKernelMetadata(runtimeMD->KernelIndexByName(name()));
// Set the argList
initArgList(kernelMD);
if (kernelMD.HasRequiredWorkgroupSize()) {
const uint32_t* requiredWorkgroupSize = kernelMD.RequiredWorkgroupSize();
workGroupInfo_.compileSize_[0] = requiredWorkgroupSize[0];
workGroupInfo_.compileSize_[1] = requiredWorkgroupSize[1];
workGroupInfo_.compileSize_[2] = requiredWorkgroupSize[2];
}
if (kernelMD.HasWorkgroupSizeHint()) {
const uint32_t* workgroupSizeHint = kernelMD.WorkgroupSizeHint();
workGroupInfo_.compileSizeHint_[0] = workgroupSizeHint[0];
workGroupInfo_.compileSizeHint_[1] = workgroupSizeHint[1];
workGroupInfo_.compileSizeHint_[2] = workgroupSizeHint[2];
}
if (kernelMD.HasVecTypeHint()) {
workGroupInfo_.compileVecTypeHint_ = kernelMD.VecTypeHint().c_str();
}
// Copy wavefront size
workGroupInfo_.wavefrontSize_ = prog().isNull() ? 64 :
dev().properties().gfxipProperties.shaderCore.wavefrontSize;
// Find total workgroup size
if (workGroupInfo_.compileSize_[0] != 0) {
workGroupInfo_.size_ =
workGroupInfo_.compileSize_[0] *
workGroupInfo_.compileSize_[1] *
workGroupInfo_.compileSize_[2];
}
else {
workGroupInfo_.size_ = dev().info().maxWorkGroupSize_;
}
initPrintf(runtimeMD->PrintfInfo());
/*FIXME_lmoriche:
size_t sizeOfWavesPerSimdHint = sizeof(workGroupInfo_.wavesPerSimdHint_);
error = aclQueryInfo(dev().compiler(), prog().binaryElf(),
RT_WAVES_PER_SIMD_HINT, openClKernelName.c_str(),
&workGroupInfo_.wavesPerSimdHint_, &sizeOfWavesPerSimdHint);
if (error != ACL_SUCCESS) {
return false;
}
waveLimiter_.enable();
*/
return true;
}
#endif // defined(WITH_LIGHTNING_COMPILER)
} // namespace pal