From 85724dd2e434c3edebb45b4f95ecc44b2bee82d1 Mon Sep 17 00:00:00 2001 From: foreman Date: Tue, 27 Feb 2018 18:38:56 -0500 Subject: [PATCH] P4 to Git Change 1520507 by skudchad@skudchad_test2_win_opencl on 2018/02/27 18:32:09 SWDEV-145570 - Populate some HIP Device Management functions. ReviewBoardURL = http://ocltc.amd.com/reviews/r/14310/diff/ Affected files ... ... //depot/stg/opencl/drivers/opencl/api/hip/hip_device.cpp#1 add ... //depot/stg/opencl/drivers/opencl/api/hip/hip_internal.hpp#1 add --- hipamd/api/hip/hip_device.cpp | 377 ++++++++++++++++++++++++++++++++ hipamd/api/hip/hip_internal.hpp | 43 ++++ 2 files changed, 420 insertions(+) create mode 100644 hipamd/api/hip/hip_device.cpp create mode 100644 hipamd/api/hip/hip_internal.hpp diff --git a/hipamd/api/hip/hip_device.cpp b/hipamd/api/hip/hip_device.cpp new file mode 100644 index 0000000000..557ee56643 --- /dev/null +++ b/hipamd/api/hip/hip_device.cpp @@ -0,0 +1,377 @@ +/* +Copyright (c) 2018 - 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 + +#include "hip_internal.hpp" + +cl_device_id* g_deviceArray = NULL; +unsigned g_deviceCnt = 0; + +hipError_t hipGetDevice(int *deviceId) { + + HIP_INIT_API(deviceId); + + if (deviceId != NULL) { + // this needs to return default device. For now return 0 always + *deviceId = 0; + } else { + return hipErrorInvalidValue; + } + + return hipSuccess; +} + +hipError_t hipDeviceGet(hipDevice_t *device, int deviceId) +{ + HIP_INIT_API(device, deviceId); + + if (device != nullptr) { + *device = deviceId; + } else { + return hipErrorInvalidValue; + } + + return hipSuccess; +}; + +hipError_t hipDeviceCount(int* count) { + + HIP_INIT_API(count); + + if (count == NULL) { + return hipErrorInvalidValue; + } + + // Get all available devices + if (!amd::Device::getDeviceIDs(CL_DEVICE_TYPE_GPU, 0, NULL, count, false)) { + return hipErrorNoDevice; + } + + return hipSuccess; +} + +hipError_t hipDeviceGetAttribute(int* pi, hipDeviceAttribute_t attr, int device) { + + HIP_INIT_API(pi, attr, device); + + if(pi == NULL) { + return hipErrorInvalidValue; + } + + auto deviceHandle = as_amd(g_deviceArray[hipDevice]); + + if (deviceHandle == NULL) { + return hipErrorInvalidDevice; + } + + hipDeviceProp_t *prop = deviceHandle->_props; + + switch (attr) { + case hipDeviceAttributeMaxThreadsPerBlock: + *pi = prop->maxThreadsPerBlock; + break; + case hipDeviceAttributeMaxBlockDimX: + *pi = prop->maxThreadsDim[0]; + break; + case hipDeviceAttributeMaxBlockDimY: + *pi = prop->maxThreadsDim[1]; + break; + case hipDeviceAttributeMaxBlockDimZ: + *pi = prop->maxThreadsDim[2]; + break; + case hipDeviceAttributeMaxGridDimX: + *pi = prop->maxGridSize[0]; + break; + case hipDeviceAttributeMaxGridDimY: + *pi = prop->maxGridSize[1]; + break; + case hipDeviceAttributeMaxGridDimZ: + *pi = prop->maxGridSize[2]; + break; + case hipDeviceAttributeMaxSharedMemoryPerBlock: + *pi = prop->sharedMemPerBlock; + break; + case hipDeviceAttributeTotalConstantMemory: + *pi = prop->totalConstMem; + break; + case hipDeviceAttributeWarpSize: + *pi = prop->warpSize; + break; + case hipDeviceAttributeMaxRegistersPerBlock: + *pi = prop->regsPerBlock; + break; + case hipDeviceAttributeClockRate: + *pi = prop->clockRate; + break; + case hipDeviceAttributeMemoryClockRate: + *pi = prop->memoryClockRate; + break; + case hipDeviceAttributeMemoryBusWidth: + *pi = prop->memoryBusWidth; + break; + case hipDeviceAttributeMultiprocessorCount: + *pi = prop->multiProcessorCount; + break; + case hipDeviceAttributeComputeMode: + *pi = prop->computeMode; + break; + case hipDeviceAttributeL2CacheSize: + *pi = prop->l2CacheSize; + break; + case hipDeviceAttributeMaxThreadsPerMultiProcessor: + *pi = prop->maxThreadsPerMultiProcessor; + break; + case hipDeviceAttributeComputeCapabilityMajor: + *pi = prop->major; + break; + case hipDeviceAttributeComputeCapabilityMinor: + *pi = prop->minor; + break; + case hipDeviceAttributePciBusId: + *pi = prop->pciBusID; + break; + case hipDeviceAttributeConcurrentKernels: + *pi = prop->concurrentKernels; + break; + case hipDeviceAttributePciDeviceId: + *pi = prop->pciDeviceID; + break; + case hipDeviceAttributeMaxSharedMemoryPerMultiprocessor: + *pi = prop->maxSharedMemoryPerMultiProcessor; + break; + case hipDeviceAttributeIsMultiGpuBoard: + *pi = prop->isMultiGpuBoard; + break; + default: + return hipErrorInvalidValue; + } + + return hipSuccess; +} + +hipError_t hipGetDeviceProperties(hipDeviceProp_t* props, int device) { + + HIP_INIT_API(props, device); + + if (props == NULL) { + return hipErrorInvalidValue; + } + + auto deviceHandle = as_amd(g_deviceArray[device]); + if (deviceHandle == NULL) { + return hipErrorInvalidDevice; + } + + hipDeviceProp_t deviceProps = {0}; + + const auto& info = deviceHandle->info(); + ::strncpy(deviceProps.name, info.boardName_, 128); + deviceProps.totalGlobalMem = info.globalMemSize_; + deviceProps.sharedMemPerBlock = info.localMemSizePerCU_; + deviceProps.regsPerBlock = info.availableSGPRs_; + deviceProps.warpSize = info.wavefrontWidth_; + deviceProps.maxThreadsPerBlock = info.maxWorkGroupSize_; + deviceProps.maxThreadsDim[0] = info.maxWorkItemSizes_[0]; + deviceProps.maxThreadsDim[1] = info.maxWorkItemSizes_[1]; + deviceProps.maxThreadsDim[2] = info.maxWorkItemSizes_[2]; + deviceProps.maxGridSize[0] = UINT32_MAX; + deviceProps.maxGridSize[1] = UINT32_MAX; + deviceProps.maxGridSize[2] = UINT32_MAX; + deviceProps.clockRate = info.maxEngineClockFrequency_; + deviceProps.memoryClockRate = info.maxMemoryClockFrequency_; + deviceProps.memoryBusWidth = info.globalMemChannels_ * 32; + deviceProps.totalConstMem = info.maxConstantBufferSize_; + deviceProps.major = info.gfxipVersion_ / 100; + deviceProps.minor = info.gfxipVersion_ % 100; + deviceProps.multiProcessorCount = info.maxComputeUnits_; + deviceProps.l2CacheSize = info.l2CacheSize_; + deviceProps.maxThreadsPerMultiProcessor = info.simdPerCU_; + deviceProps.computeMode = 0; + deviceProps.clockInstructionRate = info.timeStampFrequency_; + deviceProps.arch.hasGlobalInt32Atomics = 1; + deviceProps.arch.hasGlobalFloatAtomicExch = 1; + deviceProps.arch.hasSharedInt32Atomics = 1; + deviceProps.arch.hasSharedFloatAtomicExch = 1; + deviceProps.arch.hasFloatAtomicAdd = 0; + deviceProps.arch.hasGlobalInt64Atomics = 1; + deviceProps.arch.hasSharedInt64Atomics = 1; + deviceProps.arch.hasDoubles = 1; + deviceProps.arch.hasWarpVote = 0; + deviceProps.arch.hasWarpBallot = 0; + deviceProps.arch.hasWarpShuffle = 0; + deviceProps.arch.hasFunnelShift = 0; + deviceProps.arch.hasThreadFenceSystem = 1; + deviceProps.arch.hasSyncThreadsExt = 0; + deviceProps.arch.hasSurfaceFuncs = 0; + deviceProps.arch.has3dGrid = 1; + deviceProps.arch.hasDynamicParallelism = 0; + deviceProps.concurrentKernels = 1; + deviceProps.pciDomainID = info.deviceTopology_.function; + deviceProps.pciBusID = info.deviceTopology_.bus; + deviceProps.pciDeviceID = info.deviceTopology_.device; + deviceProps.maxSharedMemoryPerMultiProcessor = info.localMemSizePerCU_; + deviceProps.isMultiGpuBoard = info.; + deviceProps.canMapHostMemory = 1; + deviceProps.gcnArch = info.gfxipVersion_; + + *props = deviceProps; + return hipSuccess; +} + +hipError_t hipDeviceSetCacheConfig(hipFuncCache_t cacheConfig) { + + HIP_INIT_API(cacheConfig); + + // No way to set cache config yet. + + return hipSuccess; +} + +hipError_t hipDeviceGetCacheConfig(hipFuncCache_t *cacheConfig) { + HIP_INIT_API(cacheConfig); + + if(cacheConfig == NULL) { + return hipErrorInvalidValue; + } + + *cacheConfig = 0; + + return hipSuccess; +} + +hipError_t hipGetDeviceProperties(hipDeviceProp_t* properties, int device) { + + HIP_INIT_API(properties, device); + if ((properties == NULL) || (device < 0) || (device >= g_deviceCnt)) { + return hipErrorInvalidDevice; + } + + auto * deviceHandle = as_amd(g_deviceArray[device]); + if (deviceHandle != NULL) { + *properties = deviceHandle->_props; + return hipSuccess; + } + + return hipErrorInvalidDevice; +} + +hipError_t hipSetDeviceFlags(unsigned int flags) { + + HIP_INIT_API(flags); + + assert(0 && "Unimplemented") + + return hipSuccess; +}; + +hipError_t hipDeviceGetLimit (size_t *pValue, hipLimit_t limit) { + + HIP_INIT_API(pValue, limit); + + assert(0 && "Unimplemented") + + return hipSuccess; +} + +hipError_t hipFuncSetCacheConfig (const void* func, hipFuncCache_t cacheConfig) { + + HIP_INIT_API(cacheConfig); + + assert(0 && "Not supported") + + return hipSuccess; +} + +hipError_t hipDeviceSetSharedMemConfig (hipSharedMemConfig config) { + + HIP_INIT_API(config); + + assert(0 && "Not Supported") + + return hipSuccess; +} + +hipError_t hipDeviceGetSharedMemConfig (hipSharedMemConfig *pConfig) { + + HIP_INIT_API(pConfig); + + assert(0 && "Not supported") + + return hipSuccess; +} + + +hipError_t hipChooseDevice(int* device, const hipDeviceProp_t* properties) { + + HIP_INIT_API(device, properties); + + assert(0 && "Unimplemented") + + return hipSuccess; +} + + +hipError_t hipDeviceGetByPCIBusId (int* device, const char* pciBusId) { + + HIP_INIT_API(device,pciBusId); + + assert(0 && "Unimplemented") + + return hipSuccess; +} + + +hipError_t hipDeviceTotalMem (size_t *bytes,hipDevice_t device) { + + HIP_INIT_API(bytes, device); + + assert(0 && "Unimplemented") + + return hipSuccess; +} + +hipError_t hipDeviceComputeCapability(int *major, int *minor, hipDevice_t device) { + + HIP_INIT_API(major,minor, device); + assert(0 && "Unimplemented") + + return hipSuccess; +} + +hipError_t hipDeviceGetName(char *name,int len, hipDevice_t device) { + + HIP_INIT_API((void*)name,len, device); + + assert(0 && "Unimplemented") + + return hipSuccess; +} + +hipError_t hipDeviceGetPCIBusId (char *pciBusId,int len, int device) { + + HIP_INIT_API((void*)pciBusId, len, device); + + assert(0 && "Unimplemented") + + return hipSuccess; +} \ No newline at end of file diff --git a/hipamd/api/hip/hip_internal.hpp b/hipamd/api/hip/hip_internal.hpp new file mode 100644 index 0000000000..7e7b27c143 --- /dev/null +++ b/hipamd/api/hip/hip_internal.hpp @@ -0,0 +1,43 @@ +/* +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. +*/ + +#ifndef HIP_SRC_HIP_INTERNAL_H +#define HIP_SRC_HIP_INTERNAL_H + +#include "cl_common.hpp" + +#define HIP_INIT()\ + amd::Thread* thread = amd::Thread::current(); \ + if (!CL_CHECK_THREAD(thread)) { \ + return hipErrorOutOfMemory; \ + } + + +// This macro should be called at the beginning of every HIP API. +#define HIP_INIT_API(...) \ + HIP_INIT() + +extern cl_device_id* g_deviceArray; +extern unsigned g_deviceCnt; +extern thread_local cl_context g_currentCtx; + +#endif // HIP_SRC_HIP_INTERNAL_H