Laurent Morichetti
876 خطوط
26 KiB
C++
876 خطوط
26 KiB
C++
//
|
|
// Copyright (c) 2014 Advanced Micro Devices, Inc. All rights reserved.
|
|
//
|
|
#include "cl_common.hpp"
|
|
#include "cl_debugger_amd.h"
|
|
|
|
#include <cstring>
|
|
|
|
/*! \addtogroup API
|
|
* @{
|
|
*
|
|
* \addtogroup AMD_Extensions
|
|
* @{
|
|
*
|
|
*/
|
|
|
|
/*! \brief Set up the the dispatch call back function
|
|
*
|
|
* \param device specifies the device to be used
|
|
*
|
|
* \param preDispatchFunction is the function to be called before dispatching the kernel
|
|
*
|
|
* \param postDispatchFunction is the function to be called after kernel execution
|
|
*
|
|
* \return One of the following values:
|
|
* - CL_SUCCESS if the function is executed successfully
|
|
* - CL_INVALID_DEVICE if the device is not valid
|
|
* - CL_HWDBG_MANAGER_NOT_AVAILABLE_AMD if there is no HW DEBUG manager
|
|
*/
|
|
RUNTIME_ENTRY(cl_int, clHwDbgSetCallBackFunctionsAMD,
|
|
(cl_device_id device, cl_PreDispatchCallBackFunctionAMD preDispatchFunction,
|
|
cl_PostDispatchCallBackFunctionAMD postDispatchFunction)) {
|
|
if (!is_valid(device)) {
|
|
return CL_INVALID_DEVICE;
|
|
}
|
|
|
|
amd::HwDebugManager* debugManager = as_amd(device)->hwDebugMgr();
|
|
if (NULL == debugManager) {
|
|
return CL_HWDBG_MANAGER_NOT_AVAILABLE_AMD;
|
|
}
|
|
|
|
debugManager->setCallBackFunctions(preDispatchFunction, postDispatchFunction);
|
|
|
|
return CL_SUCCESS;
|
|
}
|
|
RUNTIME_EXIT
|
|
|
|
|
|
/*! \brief Set up the arguments of the dispatch call back function
|
|
*
|
|
* \param device specifies the device to be used
|
|
*
|
|
* \param preDispatchArgs is the arguments for the pre-dispatch callback function
|
|
*
|
|
* \param postDispatchArgs is the arguments for the post-dispatch callback function
|
|
*
|
|
* \return One of the following values:
|
|
* - CL_SUCCESS if the function is executed successfully
|
|
* - CL_INVALID_DEVICE if the device is not valid
|
|
* - CL_HWDBG_MANAGER_NOT_AVAILABLE_AMD if there is no HW DEBUG manager
|
|
*/
|
|
RUNTIME_ENTRY(cl_int, clHwDbgSetCallBackArgumentsAMD,
|
|
(cl_device_id device, void* preDispatchArgs, void* postDispatchArgs)) {
|
|
if (!is_valid(device)) {
|
|
return CL_INVALID_DEVICE;
|
|
}
|
|
|
|
amd::HwDebugManager* debugManager = as_amd(device)->hwDebugMgr();
|
|
if (NULL == debugManager) {
|
|
return CL_HWDBG_MANAGER_NOT_AVAILABLE_AMD;
|
|
}
|
|
|
|
debugManager->setCallBackArguments(preDispatchArgs, postDispatchArgs);
|
|
|
|
return CL_SUCCESS;
|
|
}
|
|
RUNTIME_EXIT
|
|
|
|
|
|
/*! \brief Invalidate all cache on the device.
|
|
*
|
|
* \param device specifies the device to be used
|
|
*
|
|
* \param mask is the mask to specify which cache to be flush/invalidate
|
|
*
|
|
* \return One of the following values:
|
|
* - CL_SUCCESS if the function is executed successfully
|
|
* - CL_INVALID_DEVICE if the device is not valid
|
|
* - CL_HWDBG_MANAGER_NOT_AVAILABLE_AMD if there is no HW DEBUG manager
|
|
*/
|
|
RUNTIME_ENTRY(cl_int, clHwDbgFlushCacheAMD, (cl_device_id device, cl_dbg_gpu_cache_mask_amd mask)) {
|
|
if (!is_valid(device)) {
|
|
return CL_INVALID_DEVICE;
|
|
}
|
|
|
|
amd::HwDebugManager* debugManager = as_amd(device)->hwDebugMgr();
|
|
if (NULL == debugManager) {
|
|
return CL_HWDBG_MANAGER_NOT_AVAILABLE_AMD;
|
|
}
|
|
|
|
debugManager->flushCache(mask.ui32All);
|
|
|
|
return CL_SUCCESS;
|
|
}
|
|
RUNTIME_EXIT
|
|
|
|
|
|
/*! \brief Set up an exception policy in the trap handler object
|
|
*
|
|
* \param device specifies the device to be used
|
|
*
|
|
* \param policy specifies the exception policy, which includes the exception mask,
|
|
* wave action, host action, wave mode.
|
|
*
|
|
* \return One of the following values:
|
|
* - CL_SUCCESS if the function is executed successfully
|
|
* - CL_INVALID_DEVICE if the device is not valid
|
|
* - CL_INVALID_VALUE if the policy is not specified (NULL)
|
|
* - CL_HWDBG_MANAGER_NOT_AVAILABLE_AMD if there is no HW DEBUG manager
|
|
*/
|
|
RUNTIME_ENTRY(cl_int, clHwDbgSetExceptionPolicyAMD,
|
|
(cl_device_id device, cl_dbg_exception_policy_amd* policy)) {
|
|
if (!is_valid(device)) {
|
|
return CL_INVALID_DEVICE;
|
|
}
|
|
|
|
if (NULL == policy) {
|
|
return CL_INVALID_VALUE;
|
|
}
|
|
|
|
amd::HwDebugManager* debugManager = as_amd(device)->hwDebugMgr();
|
|
if (NULL == debugManager) {
|
|
return CL_HWDBG_MANAGER_NOT_AVAILABLE_AMD;
|
|
}
|
|
|
|
debugManager->setExceptionPolicy(policy);
|
|
|
|
return CL_SUCCESS;
|
|
}
|
|
RUNTIME_EXIT
|
|
|
|
|
|
/*! \brief Get the exception policy in the trap handler object
|
|
*
|
|
* \param device specifies the device to be used
|
|
*
|
|
* \param policy is a pointer to the memory where the policy is returned
|
|
*
|
|
* \return One of the following values:
|
|
* - CL_SUCCESS if the function is executed successfully
|
|
* - CL_INVALID_DEVICE if the device is not valid
|
|
* - CL_INVALID_VALUE if the policy storage is not specified
|
|
* - CL_HWDBG_MANAGER_NOT_AVAILABLE_AMD if there is no HW DEBUG manager
|
|
*/
|
|
RUNTIME_ENTRY(cl_int, clHwDbgGetExceptionPolicyAMD,
|
|
(cl_device_id device, cl_dbg_exception_policy_amd* policy)) {
|
|
if (!is_valid(device)) {
|
|
return CL_INVALID_DEVICE;
|
|
}
|
|
|
|
if (NULL == policy) {
|
|
return CL_INVALID_VALUE;
|
|
}
|
|
|
|
amd::HwDebugManager* debugManager = as_amd(device)->hwDebugMgr();
|
|
if (NULL == debugManager) {
|
|
return CL_HWDBG_MANAGER_NOT_AVAILABLE_AMD;
|
|
}
|
|
|
|
debugManager->getExceptionPolicy(policy);
|
|
|
|
return CL_SUCCESS;
|
|
}
|
|
RUNTIME_EXIT
|
|
|
|
/*! \brief Set up the kernel execution mode in the trap handler object
|
|
*
|
|
* \param device specifies the device to be used
|
|
*
|
|
* \param mode specifies the kernel execution mode, which indicate whether single
|
|
* step mode is used, how many CUs are reserved.
|
|
*
|
|
* \return One of the following values:
|
|
* - CL_SUCCESS if the function is executed successfully
|
|
* - CL_INVALID_DEVICE if the device is not valid
|
|
* - CL_INVALID_VALUE if the mode is not specified, ie, has a NULL value
|
|
* - CL_HWDBG_MANAGER_NOT_AVAILABLE_AMD if there is no HW DEBUG manager
|
|
*/
|
|
RUNTIME_ENTRY(cl_int, clHwDbgSetKernelExecutionModeAMD,
|
|
(cl_device_id device, cl_dbg_kernel_exec_mode_amd* mode)) {
|
|
if (!is_valid(device)) {
|
|
return CL_INVALID_DEVICE;
|
|
}
|
|
|
|
if (NULL == mode) {
|
|
return CL_INVALID_VALUE;
|
|
}
|
|
|
|
amd::HwDebugManager* debugManager = as_amd(device)->hwDebugMgr();
|
|
if (NULL == debugManager) {
|
|
return CL_HWDBG_MANAGER_NOT_AVAILABLE_AMD;
|
|
}
|
|
|
|
debugManager->setKernelExecutionMode(mode);
|
|
|
|
return CL_SUCCESS;
|
|
}
|
|
RUNTIME_EXIT
|
|
|
|
|
|
/*! \brief Get the kernel execution mode in the trap handler object
|
|
*
|
|
* \param device specifies the device to be used
|
|
*
|
|
* \param mode is a pointer to the memory where the exectuion mode is returned
|
|
*
|
|
* \return One of the following values:
|
|
* - CL_SUCCESS if the function is executed successfully
|
|
* - CL_INVALID_DEVICE if the device is not valid
|
|
* - CL_INVALID_VALUE if the mode storage is not specified, ie, has a NULL value
|
|
* - CL_HWDBG_MANAGER_NOT_AVAILABLE_AMD if there is no HW DEBUG manager
|
|
*/
|
|
RUNTIME_ENTRY(cl_int, clHwDbgGetKernelExecutionModeAMD,
|
|
(cl_device_id device, cl_dbg_kernel_exec_mode_amd* mode)) {
|
|
if (!is_valid(device)) {
|
|
return CL_INVALID_DEVICE;
|
|
}
|
|
|
|
if (NULL == mode) {
|
|
return CL_INVALID_VALUE;
|
|
}
|
|
|
|
amd::HwDebugManager* debugManager = as_amd(device)->hwDebugMgr();
|
|
if (NULL == debugManager) {
|
|
return CL_HWDBG_MANAGER_NOT_AVAILABLE_AMD;
|
|
}
|
|
|
|
debugManager->getKernelExecutionMode(mode);
|
|
|
|
return CL_SUCCESS;
|
|
}
|
|
RUNTIME_EXIT
|
|
|
|
/*! \brief Create a trap event for debugging
|
|
*
|
|
* \param device specifies the device to be used
|
|
*
|
|
* \param autoReset is the auto reset flag
|
|
*
|
|
* \param pDebugEvent returns the debug event to be used for exception notification
|
|
*
|
|
* \param pEventId is the event ID, which is not used at this moment
|
|
*
|
|
* \return One of the following values:
|
|
* - CL_SUCCESS if the function is executed successfully
|
|
* - CL_INVALID_DEVICE if the device is not valid
|
|
* - CL_INVALID_VALUE if the pDebugEvent value is NULL
|
|
* - CL_HWDBG_MANAGER_NOT_AVAILABLE_AMD if there is no HW DEBUG manager
|
|
* - CL_OUT_OF_RESOURCES if fails to create the event
|
|
*/
|
|
RUNTIME_ENTRY(cl_int, clHwDbgCreateEventAMD, (cl_device_id device, bool autoReset,
|
|
cl_dbg_event_amd* pDebugEvent, cl_uint* pEventId)) {
|
|
if (!is_valid(device)) {
|
|
return CL_INVALID_DEVICE;
|
|
}
|
|
|
|
if (NULL == pDebugEvent) {
|
|
return CL_INVALID_VALUE;
|
|
}
|
|
|
|
amd::HwDebugManager* debugManager = as_amd(device)->hwDebugMgr();
|
|
if (NULL == debugManager) {
|
|
return CL_HWDBG_MANAGER_NOT_AVAILABLE_AMD;
|
|
}
|
|
|
|
// set it to zero for now - not used by OpenCL
|
|
*pEventId = 0;
|
|
*pDebugEvent = debugManager->createDebugEvent(autoReset);
|
|
|
|
return (NULL == pDebugEvent) ? CL_OUT_OF_RESOURCES : CL_SUCCESS;
|
|
}
|
|
RUNTIME_EXIT
|
|
|
|
/*! \brief Wait for a debug event to be signaled
|
|
*
|
|
* \param device specifies the device to be used
|
|
*
|
|
* \param pDebugEvent is the debug event to be waited for
|
|
*
|
|
* \param pEventId is the event ID, which is not used at this moment
|
|
*
|
|
* \param timeOut is the duration for waiting
|
|
*
|
|
* \return One of the following values:
|
|
* - CL_SUCCESS if the event occurs before the timeout
|
|
* - CL_INVALID_DEVICE if the device is not valid
|
|
* - CL_INVALID_VALUE if the pDebugEvent value is NULL
|
|
* - CL_HWDBG_MANAGER_NOT_AVAILABLE_AMD if there is no HW DEBUG manager
|
|
* - CL_EVENT_TIMEOUT_AMD if timeout occurs
|
|
*/
|
|
RUNTIME_ENTRY(cl_int, clHwDbgWaitEventAMD, (cl_device_id device, cl_dbg_event_amd pDebugEvent,
|
|
cl_uint pEventId, cl_uint timeOut)) {
|
|
if (!is_valid(device)) {
|
|
return CL_INVALID_DEVICE;
|
|
}
|
|
|
|
if (0 == pDebugEvent) {
|
|
return CL_INVALID_VALUE;
|
|
}
|
|
|
|
amd::HwDebugManager* debugManager = as_amd(device)->hwDebugMgr();
|
|
if (NULL == debugManager) {
|
|
return CL_HWDBG_MANAGER_NOT_AVAILABLE_AMD;
|
|
}
|
|
|
|
return debugManager->waitDebugEvent(pDebugEvent, timeOut);
|
|
}
|
|
RUNTIME_EXIT
|
|
|
|
/*! \brief Destroy a trap event for debugging
|
|
*
|
|
* \param device specifies the device to be used
|
|
*
|
|
* \param pDebugEvent is the debug event to be waited for
|
|
*
|
|
* \param pEventId is the event ID, which is not used at this moment
|
|
*
|
|
* \return One of the following values:
|
|
* - CL_SUCCESS if the event occurs before the timeout
|
|
* - CL_INVALID_DEVICE if the device is not valid
|
|
* - CL_INVALID_VALUE if the pDebugEvent value is NULL
|
|
* - CL_HWDBG_MANAGER_NOT_AVAILABLE_AMD if there is no HW DEBUG manager
|
|
*/
|
|
RUNTIME_ENTRY(cl_int, clHwDbgDestroyEventAMD,
|
|
(cl_device_id device, cl_dbg_event_amd* pDebugEvent, cl_uint* pEventId)) {
|
|
if (!is_valid(device)) {
|
|
return CL_INVALID_DEVICE;
|
|
}
|
|
|
|
if (NULL == pDebugEvent) {
|
|
return CL_INVALID_VALUE;
|
|
}
|
|
|
|
amd::HwDebugManager* debugManager = as_amd(device)->hwDebugMgr();
|
|
if (NULL == debugManager) {
|
|
return CL_HWDBG_MANAGER_NOT_AVAILABLE_AMD;
|
|
}
|
|
|
|
debugManager->destroyDebugEvent(pDebugEvent);
|
|
|
|
return CL_SUCCESS;
|
|
}
|
|
RUNTIME_EXIT
|
|
|
|
|
|
/*! \brief Register the debugger on a device
|
|
*
|
|
* \param context specifies the context for the debugger
|
|
*
|
|
* \param device specifies the device to be used
|
|
*
|
|
* \param pMessageStorge specifies the memory for trap message passing between KMD and OCL runtime
|
|
*
|
|
* \return One of the following values:
|
|
* - CL_SUCCESS if the event occurs before the timeout
|
|
* - CL_INVALID_CONTEXT if the context is not valid
|
|
* - CL_INVALID_DEVICE if the device is not valid
|
|
* - CL_INVALID_VALUE if the pMEssageStorge value is NULL
|
|
* - CL_HWDBG_MANAGER_NOT_AVAILABLE_AMD if there is no HW DEBUG manager
|
|
* - CL_OUT_OF_RESOURCES if a host queue cannot be created for the debugger
|
|
*/
|
|
RUNTIME_ENTRY(cl_int, clHwDbgRegisterDebuggerAMD,
|
|
(cl_context context, cl_device_id device, volatile void* pMessageStorage)) {
|
|
if (!is_valid(device)) {
|
|
return CL_INVALID_DEVICE;
|
|
}
|
|
|
|
if (!is_valid(context)) {
|
|
return CL_INVALID_CONTEXT;
|
|
}
|
|
|
|
if (NULL == pMessageStorage) {
|
|
return CL_INVALID_VALUE;
|
|
}
|
|
|
|
if (NULL == as_amd(device)->hwDebugMgr()) {
|
|
return CL_HWDBG_MANAGER_NOT_AVAILABLE_AMD;
|
|
}
|
|
|
|
return as_amd(device)->hwDebugManagerInit(as_amd(context),
|
|
reinterpret_cast<uintptr_t>(pMessageStorage));
|
|
}
|
|
RUNTIME_EXIT
|
|
|
|
|
|
/*! \brief Unregister the debugger on a device
|
|
*
|
|
* \param device specifies the device to be used
|
|
*
|
|
* \return One of the following values:
|
|
* - CL_SUCCESS if the event occurs before the timeout
|
|
* - CL_INVALID_DEVICE if the device is not valid
|
|
* - CL_HWDBG_MANAGER_NOT_AVAILABLE_AMD if there is no HW DEBUG manager
|
|
*/
|
|
RUNTIME_ENTRY(cl_int, clHwDbgUnregisterDebuggerAMD, (cl_device_id device)) {
|
|
if (!is_valid(device)) {
|
|
return CL_INVALID_DEVICE;
|
|
}
|
|
|
|
amd::HwDebugManager* debugManager = as_amd(device)->hwDebugMgr();
|
|
if (NULL == debugManager) {
|
|
return CL_HWDBG_MANAGER_NOT_AVAILABLE_AMD;
|
|
}
|
|
|
|
debugManager->unregisterDebugger();
|
|
|
|
return CL_SUCCESS;
|
|
}
|
|
RUNTIME_EXIT
|
|
|
|
/*! \brief Setup the pointer of the acl_binary to be used by the debugger
|
|
*
|
|
* \param device specifies the device to be used
|
|
*
|
|
* \param aclBinary specifies the ACL binary to be used
|
|
*
|
|
* \return One of the following values:
|
|
* - CL_SUCCESS if the event occurs before the timeout
|
|
* - CL_INVALID_DEVICE if the device is not valid
|
|
* - CL_INVALID_VALUE if the aclBinary is not provided
|
|
* - CL_HWDBG_MANAGER_NOT_AVAILABLE_AMD if there is no HW DEBUG manager
|
|
*/
|
|
RUNTIME_ENTRY(cl_int, clHwDbgSetAclBinaryAMD, (cl_device_id device, void* aclBinary)) {
|
|
if (!is_valid(device)) {
|
|
return CL_INVALID_DEVICE;
|
|
}
|
|
|
|
if (NULL == aclBinary) {
|
|
LogWarning("clHwDbgSetAclBinaryAMD: Invalid ACL binary argument.");
|
|
return CL_INVALID_VALUE;
|
|
}
|
|
|
|
amd::HwDebugManager* debugManager = as_amd(device)->hwDebugMgr();
|
|
if (NULL == debugManager) {
|
|
return CL_HWDBG_MANAGER_NOT_AVAILABLE_AMD;
|
|
}
|
|
|
|
debugManager->setAclBinary(aclBinary);
|
|
|
|
return CL_SUCCESS;
|
|
}
|
|
RUNTIME_EXIT
|
|
|
|
/*! \brief Control the execution of wavefront on the GPU
|
|
*
|
|
* \param device specifies the device to be used
|
|
*
|
|
* \param action specifies the wave action - halt, resume, kill, debug
|
|
*
|
|
* \param mode specifies the wave mode
|
|
*
|
|
* \param trapId specifies the trap ID, which should be 0x7
|
|
*
|
|
* \param waveAddress specifies the wave address for the wave control
|
|
*
|
|
* \return One of the following values:
|
|
* - CL_SUCCESS if the event occurs before the timeout
|
|
* - CL_INVALID_DEVICE if the device is not valid
|
|
* - CL_INVALID_VALUE if the waveMsg is not provided, invalid action or mode value
|
|
* - CL_HWDBG_MANAGER_NOT_AVAILABLE_AMD if there is no HW DEBUG manager
|
|
*/
|
|
RUNTIME_ENTRY(cl_int, clHwDbgWaveControlAMD,
|
|
(cl_device_id device, cl_dbg_waves_action_amd action, cl_dbg_wave_mode_amd mode,
|
|
cl_uint trapId, cl_dbg_wave_addr_amd waveAddress)) {
|
|
if (!is_valid(device)) {
|
|
return CL_INVALID_DEVICE;
|
|
}
|
|
|
|
// validate the passing arguments
|
|
//
|
|
if (action < 0 || action >= CL_DBG_WAVES_MAX) {
|
|
LogWarning("clHwDbgWaveControlAMD: Invalid wave action argument");
|
|
return CL_INVALID_VALUE;
|
|
}
|
|
|
|
if ((mode != CL_DBG_WAVEMODE_SINGLE) && (mode != CL_DBG_WAVEMODE_BROADCAST) &&
|
|
(mode != CL_DBG_WAVEMODE_BROADCAST_CU)) {
|
|
LogWarning("clHwDbgWaveControlAMD: Invalid wave mode argument");
|
|
return CL_INVALID_VALUE;
|
|
}
|
|
|
|
amd::HwDebugManager* debugManager = as_amd(device)->hwDebugMgr();
|
|
if (NULL == debugManager) {
|
|
return CL_HWDBG_MANAGER_NOT_AVAILABLE_AMD;
|
|
}
|
|
|
|
debugManager->wavefrontControl(action, mode, trapId, (void*)&waveAddress);
|
|
|
|
return CL_SUCCESS;
|
|
}
|
|
RUNTIME_EXIT
|
|
|
|
|
|
/*! \brief Set watch points on memory address ranges to generate exception events
|
|
*
|
|
* \param device specifies the device to be used
|
|
*
|
|
* \param numWatchPoints specifies the number of watch points
|
|
*
|
|
* \param watchMode is the array of watch mode for the watch points
|
|
*
|
|
* \param watchAddress is the array of watch address for the watch points
|
|
*
|
|
* \param watchMask is the array of mask for the watch points
|
|
*
|
|
* \param watchEvent is the array of event for the watch points
|
|
*
|
|
* \return One of the following values:
|
|
* - CL_SUCCESS if the event occurs before the timeout
|
|
* - CL_INVALID_DEVICE if the device is not valid
|
|
* - CL_INVALID_VALUE if the number of points <= 0, or other parameters is not specified
|
|
* - CL_HWDBG_MANAGER_NOT_AVAILABLE_AMD if there is no HW DEBUG manager
|
|
*/
|
|
RUNTIME_ENTRY(cl_int, clHwDbgAddressWatchAMD,
|
|
(cl_device_id device, cl_uint numWatchPoints,
|
|
cl_dbg_address_watch_mode_amd* watchMode, void** watchAddress, cl_ulong* watchMask,
|
|
cl_dbg_event_amd* watchEvent)) {
|
|
if (!is_valid(device)) {
|
|
return CL_INVALID_DEVICE;
|
|
}
|
|
|
|
// validate the passing arguments
|
|
if (numWatchPoints <= 0) {
|
|
LogWarning("clHwDbgAddressWatchAMD: Invalid number of watch points argument");
|
|
return CL_INVALID_VALUE;
|
|
}
|
|
|
|
if (NULL == watchMode) {
|
|
LogWarning("clHwDbgAddressWatchAMD: Watch mode argument");
|
|
return CL_INVALID_VALUE;
|
|
}
|
|
|
|
if (NULL == watchAddress) {
|
|
LogWarning("clHwDbgAddressWatchAMD: Watch address argument");
|
|
return CL_INVALID_VALUE;
|
|
}
|
|
|
|
if (NULL == watchMask) {
|
|
LogWarning("clHwDbgAddressWatchAMD: Watch mask argument");
|
|
return CL_INVALID_VALUE;
|
|
}
|
|
|
|
// TODO: WC - confirm how the watch event is used.
|
|
//
|
|
amd::HwDebugManager* debugManager = as_amd(device)->hwDebugMgr();
|
|
if (NULL == debugManager) {
|
|
return CL_HWDBG_MANAGER_NOT_AVAILABLE_AMD;
|
|
}
|
|
|
|
debugManager->setAddressWatch(numWatchPoints, watchAddress, watchMask,
|
|
reinterpret_cast<cl_ulong*>(watchMode), watchEvent);
|
|
|
|
return CL_SUCCESS;
|
|
}
|
|
RUNTIME_EXIT
|
|
|
|
|
|
/*! \brief Get the AQL packet information for kernel dispatch
|
|
*
|
|
* \param device specifies the device to be used
|
|
*
|
|
* \param aqlPacket specifies the AQL packet
|
|
*
|
|
* \param aqlCodeInfo specifies the kernel code and its size
|
|
*
|
|
* \param packetInfo points to the memory for the packet information to be returned
|
|
*
|
|
* \return One of the following values:
|
|
* - CL_SUCCESS if the event occurs before the timeout
|
|
* - CL_INVALID_DEVICE if the device is not valid
|
|
* - CL_HWDBG_MANAGER_NOT_AVAILABLE_AMD if there is no HW DEBUG manager
|
|
*/
|
|
RUNTIME_ENTRY(cl_int, clHwDbgGetAqlPacketInfoAMD,
|
|
(cl_device_id device, const void* aqlCodeInfo, cl_aql_packet_info_amd* packetInfo)) {
|
|
if (!is_valid(device)) {
|
|
return CL_INVALID_DEVICE;
|
|
}
|
|
|
|
amd::HwDebugManager* debugManager = as_amd(device)->hwDebugMgr();
|
|
if (NULL == debugManager) {
|
|
return CL_HWDBG_MANAGER_NOT_AVAILABLE_AMD;
|
|
}
|
|
|
|
debugManager->getPacketAmdInfo(aqlCodeInfo, packetInfo);
|
|
|
|
return CL_SUCCESS;
|
|
}
|
|
RUNTIME_EXIT
|
|
|
|
|
|
/*! \brief Get the dispatch debug information
|
|
*
|
|
* \param device specifies the device to be used
|
|
*
|
|
* \param debugInfo points to the memory for the debug information to be returned
|
|
*
|
|
* \return One of the following values:
|
|
* - CL_SUCCESS if the event occurs before the timeout
|
|
* - CL_INVALID_DEVICE if the device is not valid
|
|
* - CL_HWDBG_MANAGER_NOT_AVAILABLE_AMD if there is no HW DEBUG manager
|
|
*/
|
|
RUNTIME_ENTRY(cl_int, clHwDbgGetDispatchDebugInfoAMD,
|
|
(cl_device_id device, cl_dispatch_debug_info_amd* debugInfo)) {
|
|
if (!is_valid(device)) {
|
|
return CL_INVALID_DEVICE;
|
|
}
|
|
|
|
if (NULL == debugInfo) {
|
|
LogWarning("clHwDbgGetDispatchDebugInfoAMD: Invalid debug information pointer.");
|
|
return CL_INVALID_VALUE;
|
|
}
|
|
|
|
amd::HwDebugManager* debugManager = as_amd(device)->hwDebugMgr();
|
|
if (NULL == debugManager) {
|
|
return CL_HWDBG_MANAGER_NOT_AVAILABLE_AMD;
|
|
}
|
|
|
|
debugManager->getDispatchDebugInfo((void*)debugInfo);
|
|
|
|
return CL_SUCCESS;
|
|
}
|
|
RUNTIME_EXIT
|
|
|
|
/*! \brief Map the video memory for the kernel code to allow host access
|
|
*
|
|
* \param device specifies the device to be used
|
|
*
|
|
* \param aqlCodeInfo specifies the kernel code and its size
|
|
*
|
|
* \return One of the following values:
|
|
* - CL_SUCCESS if the event occurs before the timeout
|
|
* - CL_INVALID_DEVICE if the device is not valid
|
|
* - CL_HWDBG_MANAGER_NOT_AVAILABLE_AMD if there is no HW DEBUG manager
|
|
*/
|
|
RUNTIME_ENTRY(cl_int, clHwDbgMapKernelCodeAMD, (cl_device_id device, void* aqlCodeInfo)) {
|
|
if (!is_valid(device)) {
|
|
return CL_INVALID_DEVICE;
|
|
}
|
|
|
|
amd::HwDebugManager* debugManager = as_amd(device)->hwDebugMgr();
|
|
if (NULL == debugManager) {
|
|
return CL_HWDBG_MANAGER_NOT_AVAILABLE_AMD;
|
|
}
|
|
|
|
debugManager->mapKernelCode(aqlCodeInfo);
|
|
|
|
return CL_SUCCESS;
|
|
}
|
|
RUNTIME_EXIT
|
|
|
|
/*! \brief Unmap the video memory for the kernel code
|
|
*
|
|
* \param device specifies the device to be used (no needed, just to be consistent)
|
|
*
|
|
* \param aqlCodeAddress is the memory points to the mapped memory address for the kernel code
|
|
*
|
|
* \return One of the following values:
|
|
* - CL_SUCCESS if the event occurs before the timeout
|
|
* - CL_INVALID_DEVICE if the device is not valid
|
|
* - CL_HWDBG_MANAGER_NOT_AVAILABLE_AMD if there is no HW DEBUG manager
|
|
*/
|
|
RUNTIME_ENTRY(cl_int, clHwDbgUnmapKernelCodeAMD, (cl_device_id device, cl_ulong* aqlCodeAddress)) {
|
|
if (!is_valid(device)) {
|
|
return CL_INVALID_DEVICE;
|
|
}
|
|
|
|
if (NULL == aqlCodeAddress) {
|
|
LogWarning("clHwDbgUnmapKernelCodeAMD: Invalid AQL code address argument.");
|
|
return CL_INVALID_VALUE;
|
|
}
|
|
|
|
// Shader buffer is always pinned to host memory so there is no need to unmap the memory.
|
|
// Just set it to 0 to avoid unwanted access
|
|
*aqlCodeAddress = 0;
|
|
|
|
return CL_SUCCESS;
|
|
}
|
|
RUNTIME_EXIT
|
|
|
|
/*! \brief Map the scratch ring's memory to allow CPU access
|
|
*
|
|
* \param device specifies the device to be used
|
|
*
|
|
* \param scratchRingAddr is the memory points to the returned host memory address for scratch
|
|
* ring
|
|
*
|
|
* \param scratchRingSize returns the size of the scratch ring
|
|
*
|
|
* \return One of the following values:
|
|
* - CL_SUCCESS if the event occurs before the timeout
|
|
* - CL_INVALID_DEVICE if the device is not valid
|
|
* - CL_HWDBG_MANAGER_NOT_AVAILABLE_AMD if there is no HW DEBUG manager
|
|
*/
|
|
RUNTIME_ENTRY(cl_int, clHwDbgMapScratchRingAMD,
|
|
(cl_device_id device, cl_ulong* scratchRingAddr, cl_uint* scratchRingSize)) {
|
|
if (!is_valid(device)) {
|
|
return CL_INVALID_DEVICE;
|
|
}
|
|
|
|
amd::HwDebugManager* debugManager = as_amd(device)->hwDebugMgr();
|
|
if (NULL == debugManager) {
|
|
return CL_HWDBG_MANAGER_NOT_AVAILABLE_AMD;
|
|
}
|
|
|
|
debugManager->mapScratchRing(scratchRingAddr, scratchRingSize);
|
|
|
|
return CL_SUCCESS;
|
|
}
|
|
RUNTIME_EXIT
|
|
|
|
/*! \brief Unmap the shader scratch ring's video memory
|
|
*
|
|
* \param device specifies the device to be used (no needed, just to be consistent)
|
|
*
|
|
* \param scratchRingAddr is the memory points to the mapped memory address for scratch ring
|
|
*
|
|
* \return One of the following values:
|
|
* - CL_SUCCESS if the event occurs before the timeout
|
|
* - CL_INVALID_DEVICE if the device is not valid
|
|
* - CL_HWDBG_MANAGER_NOT_AVAILABLE_AMD if there is no HW DEBUG manager
|
|
*/
|
|
RUNTIME_ENTRY(cl_int, clHwDbgUnmapScratchRingAMD,
|
|
(cl_device_id device, cl_ulong* scratchRingAddr)) {
|
|
if (!is_valid(device)) {
|
|
return CL_INVALID_DEVICE;
|
|
}
|
|
|
|
if (NULL == scratchRingAddr) {
|
|
LogWarning("clHwDbgUnmapScratchRingAMD: Invalid scratch ring address argument.");
|
|
return CL_INVALID_VALUE;
|
|
}
|
|
|
|
// Scratch ring buffer is always pinned to host memory so there is no need to unmap the memory.
|
|
// Just set it to NULL to avoid unwanted access
|
|
*scratchRingAddr = 0;
|
|
|
|
return CL_SUCCESS;
|
|
}
|
|
RUNTIME_EXIT
|
|
|
|
|
|
/*! \brief Get the memory object associated with the kernel parameter
|
|
*
|
|
* \param device specifies the device to be used
|
|
*
|
|
* \param paramIdx is the index of of the kernel argument
|
|
*
|
|
* \param paramMem is pointer of the memory associated with the kernel argument to be returned
|
|
*
|
|
* \return One of the following values:
|
|
* - CL_SUCCESS if the event occurs before the timeout
|
|
* - CL_INVALID_DEVICE if the device is not valid
|
|
* - CL_INVALID_VALUE if the paramIdx is less than zero, or the paramMem has NULL value
|
|
* - CL_HWDBG_MANAGER_NOT_AVAILABLE_AMD if there is no HW DEBUG manager
|
|
* - CL_INVALID_KERNEL_ARGS if it fails to get the memory object for the kernel argument
|
|
*/
|
|
RUNTIME_ENTRY(cl_int, clHwDbgGetKernelParamMemAMD,
|
|
(cl_device_id device, cl_uint paramIdx, cl_mem* paramMem)) {
|
|
if (!is_valid(device)) {
|
|
return CL_INVALID_DEVICE;
|
|
}
|
|
|
|
amd::Device* amdDevice = as_amd(device);
|
|
|
|
if (paramIdx < 0) {
|
|
LogWarning("clHwDbgGetKernelParamMemAMD: Invalid parameter index argument.");
|
|
return CL_INVALID_VALUE;
|
|
}
|
|
|
|
if (NULL == paramMem) {
|
|
LogWarning("clHwDbgGetKernelParamMemAMD: Invalid parameter member object argument.");
|
|
return CL_INVALID_VALUE;
|
|
}
|
|
|
|
amd::HwDebugManager* debugManager = amdDevice->hwDebugMgr();
|
|
if (NULL == debugManager) {
|
|
return CL_HWDBG_MANAGER_NOT_AVAILABLE_AMD;
|
|
}
|
|
|
|
*paramMem = debugManager->getKernelParamMem(paramIdx);
|
|
|
|
return (*paramMem == 0) ? CL_INVALID_KERNEL_ARGS : CL_SUCCESS;
|
|
}
|
|
RUNTIME_EXIT
|
|
|
|
/*! \brief Set value of a global memory object
|
|
*
|
|
* \param device specifies the device to be used
|
|
*
|
|
* \param memObject is the memory object handle to be assigned the value specified in srcMem.
|
|
*
|
|
* \param offset is offset of the memory object
|
|
*
|
|
* \param srcMem points to the memory which contains the values to be assigned to the memory
|
|
*
|
|
* \param size size (in bytes) of the srcMem
|
|
*
|
|
* \return One of the following values:
|
|
* - CL_SUCCESS if the event occurs before the timeout
|
|
* - CL_INVALID_DEVICE if the device is not valid
|
|
* - CL_INVALID_VALUE if memObj or srcPtr has NULL value, size <= 0 or offset < 0
|
|
* - CL_HWDBG_MANAGER_NOT_AVAILABLE_AMD if there is no HW DEBUG manager
|
|
*/
|
|
RUNTIME_ENTRY(cl_int, clHwDbgSetGlobalMemoryAMD,
|
|
(cl_device_id device, cl_mem memObject, cl_uint offset, void* srcMem, cl_uint size)) {
|
|
if (!is_valid(device)) {
|
|
return CL_INVALID_DEVICE;
|
|
}
|
|
|
|
amd::HwDebugManager* debugManager = as_amd(device)->hwDebugMgr();
|
|
if (NULL == debugManager) {
|
|
return CL_HWDBG_MANAGER_NOT_AVAILABLE_AMD;
|
|
}
|
|
|
|
if (0 > offset || 0 >= size) {
|
|
return CL_INVALID_VALUE;
|
|
}
|
|
|
|
amd::Memory* globalMem = as_amd(memObject);
|
|
debugManager->setGlobalMemory(globalMem, offset, srcMem, size);
|
|
|
|
return CL_SUCCESS;
|
|
}
|
|
RUNTIME_EXIT
|
|
|
|
|
|
/*! \brief Install the trap handler of a given type
|
|
*
|
|
* \param device specifies the device to be used
|
|
*
|
|
* \param trapType is the type of trap handler
|
|
*
|
|
* \param trapHandler is the pointer of trap handler (TBA)
|
|
*
|
|
* \param trapBuffer is the pointer of trap handler buffer (TMA)
|
|
*
|
|
* \return One of the following values:
|
|
* - CL_SUCCESS if the event occurs before the timeout
|
|
* - CL_INVALID_DEVICE if the device is not valid
|
|
* - CL_HWDBG_MANAGER_NOT_AVAILABLE_AMD if there is no HW DEBUG manager
|
|
*/
|
|
RUNTIME_ENTRY(cl_int, clHwDbgInstallTrapAMD, (cl_device_id device, cl_dbg_trap_type_amd trapType,
|
|
cl_mem trapHandler, cl_mem trapBuffer)) {
|
|
if (!is_valid(device)) {
|
|
return CL_INVALID_DEVICE;
|
|
}
|
|
|
|
amd::HwDebugManager* debugManager = as_amd(device)->hwDebugMgr();
|
|
if (NULL == debugManager) {
|
|
return CL_HWDBG_MANAGER_NOT_AVAILABLE_AMD;
|
|
}
|
|
|
|
amd::Memory* pTrapHandler = as_amd(trapHandler);
|
|
amd::Memory* pTrapBuffer = as_amd(trapBuffer);
|
|
debugManager->installTrap(trapType, pTrapHandler, pTrapBuffer);
|
|
|
|
return CL_SUCCESS;
|
|
}
|
|
|
|
RUNTIME_EXIT
|
|
|
|
|
|
/*! @}
|
|
* @}
|
|
*/
|