/* Copyright (c) 2014-present Advanced Micro Devices, Inc.

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 __CL_DEBUGGER_AMD_H

#define __CL_DEBUGGER_AMD_H

#ifdef __APPLE__

#include <OpenCL/cl_platform.h>

#else

#include <CL/cl_platform.h>

#endif

/******************************************

* Private AMD extension cl_dbg *

******************************************/

#ifdef __cplusplus

extern "C" {

#endif /*__cplusplus*/

#define CL_HWDBG_MANAGER_NOT_AVAILABLE_AMD -80

#define CL_DEBUGGER_REGISTER_FAILURE_AMD -81

#define CL_TRAP_HANDLER_NOT_DEFINED_AMD -82

#define CL_EVENT_TIMEOUT_AMD -83

typedef uintptr_t cl_dbg_event_amd; //! debug event

/*! \brief Trap Handler Type

*

* The trap handler for each support type.

*/

enum cl_dbg_trap_type_amd {

CL_DBG_DEBUG_TRAP = 0, //! HW debug

CL_DBG_MAX_TRAP

};

/*! \brief Wave actions used to control the wave execution on the hardware

*

* The wave action enumerations are used to specify the desired

* behavior when calling the wave control function. Overall, there are

* five types of operations that can be specified.

*/

enum cl_dbg_waves_action_amd {

CL_DBG_WAVES_DONT_USE_ZERO = 0, //! NOT USED

CL_DBG_WAVES_HALT = 1, //! halt wave

CL_DBG_WAVES_RESUME = 2, //! resume wave

CL_DBG_WAVES_KILL = 3, //! kill wave

CL_DBG_WAVES_DEBUG = 4, //! debug wave

CL_DBG_WAVES_TRAP = 5, //! trap

CL_DBG_WAVES_MAX

};

/*! \brief Host actions when encountering an exception in the kernel.

*

* The host action enumeration is used to specify the desired host

* response in the event thatn a device kernel exception is encountered.

*/

enum cl_dbg_host_action_amd {

CL_DBG_HOST_IGNORE = 1, //! ignore the kernel exception

CL_DBG_HOST_EXIT = 2, //! exit the host application on a kernel exception

CL_DBG_HOST_NOTIFY = 4 //! report the kernel exception

};

/*! \brief Mode of the wave action when calling the wave control function

*

* The wave mode enumerations are used to specify the desired

* broadcast level when calling the wave control function.

*/

enum cl_dbg_wave_mode_amd {

CL_DBG_WAVEMODE_SINGLE = 0, //! send command to single wave

CL_DBG_WAVEMODE_BROADCAST = 2, //! send command to wave with match VMID

CL_DBG_WAVEMODE_BROADCAST_CU = 3, //! send command to wave with match VMID with specific CU

CL_DBG_WAVEMODE_MAX

};

/*! \brief Enumeration of address watch mode

*

* This enumeration indicates the different modes of address watch.

*/

enum cl_dbg_address_watch_mode_amd {

CL_DBG_ADDR_WATCH_MODE_READ = 0, //! Read operations only

CL_DBG_ADDR_WATCH_MODE_NONREAD = 1, //! Write or Atomic operations only

CL_DBG_ADDR_WATCH_MODE_ATOMIC = 2, //! Atomic Operations only

CL_DBG_ADDR_WATCH_MODE_ALL = 3, //! Read, Write or Atomic operations

CL_DBG_ADDR_WATCH_MODE_MAX //! Number of address watch modes

};

/*! \brief Dispatch exception policy descriptor

*

* The dispatch exception policy descriptor is used to define the

* expected exception policy in the event an exception is encountered

* on the associated dispatch.

*/

typedef struct _cl_dbg_exception_policy_amd {

cl_uint exceptionMask; //! exception mask

cl_dbg_waves_action_amd waveAction; //! wave action

cl_dbg_host_action_amd hostAction; //! host action

cl_dbg_wave_mode_amd waveMode; //! wave mode

} cl_dbg_exception_policy_amd;

/*! \brief Kernel execution mode

*

* This structure is used to control the kernel execution mode. The

* following aspects are included in this structure:

* 1. Regular execution or debug mode (0: regular execution (default),

* 1: debug mode)

* 2. SQ debugger mode on/off

* 3. Disable L1 scalar cache (0: enable (default), 1: disable)

* 4. Disable L1 vector cache (0: enable (default), 1: disable)

* 5. Disable L2 cache (0: enable (default), 1: disable)

* 6. Num of CUs reserved for display (0 (default), 7: max)

*/

typedef struct _cl_dbg_kernel_exec_mode_amd {

union {

struct {

cl_uint monitorMode : 1;

cl_uint gpuSingleStepMode : 1;

cl_uint disableL1Scalar : 1;

cl_uint disableL1Vector : 1;

cl_uint disableL2Cache : 1;

cl_uint reservedCuNum : 3;

cl_uint reserved : 24;

};

cl_uint ui32All;

};

} cl_dbg_kernel_exec_mode_amd;

/*! \brief GPU cache mask

*

* This structure is used to specify the GPU cache to be flushed/invalidated

*/

typedef struct _cl_dbg_gpu_cache_mask_amd {

union {

struct {

cl_uint sqICache : 1; //! instruction cache

cl_uint sqKCache : 1; //! data cache

cl_uint tcL1 : 1; //! tcL1 cache

cl_uint tcL2 : 1; //! tcL2 cache

cl_uint reserved : 28;

};

cl_uint ui32All;

};

} cl_dbg_gpu_cache_mask_amd;

/*! \brief Dispatch Debug Info

*

* This structure is used to store the scratch and global memory descriptors

*/

typedef struct _cl_dispatch_debug_info_amd {

cl_uint scratchMemoryDescriptor[4]; //! Scratch memory descriptors

cl_uint globalMemoryDescriptor[4]; //! Global memory descriptors

} cl_dispatch_debug_info_amd;

/*! \brief AQL Packet Info

*

* This structure is used to store AQL packet informatin for kernel dispatch

*/

typedef struct _cl_aql_packet_info_amd {

cl_uint trapReservedVgprIndex; //! VGPR index reserved for trap

//! value is -1 when kernel was not compiled

//! in debug mode.

cl_uint scratchBufferWaveOffset; //! scratch buffer wave offset

//! value is -1 when kernel was not compiled

//! in debug mode or scratch buffer is not enabled

void* pointerToIsaBuffer; //! Pointer to buffer containing ISA

size_t sizeOfIsaBuffer; //! Size of the ISA buffer

cl_uint numberOfVgprs; //! Number of VGPRs used by the kernel

cl_uint numberOfSgprs; //! Number of SGPRs used by the kernel

size_t sizeOfStaticGroupMemory; //! Static local memory used by the kernel

} cl_aql_packet_info_amd;

/*! \brief Wave address

*

* This structure specifies the wave for the SQ control command

*/

typedef struct _cl_dbg_wave_addr_amd {

cl_uint shaderEngine : 2; //! Shader engine

cl_uint shaderArray : 1; //! Shader array

cl_uint computeUnit : 4; //! Compute unit

cl_uint simd : 2; //! SIMD id

cl_uint wave : 4; //! Wave id

cl_uint vmid : 4; //! VMID

cl_uint reserved : 15;

} cl_dbg_wave_addr_amd;

/*! \brief Pre-dispatch call back function signature

*

* This is the signature of the call back fuction before the kernel

* dispatch. The call back function is to indicate the start of the

* the kernel launch. It is used by the debugger.

*/

typedef void* (*cl_PreDispatchCallBackFunctionAMD)(cl_device_id device, void* ocl_event_handle,

const void* aql_packet, void* acl_binary,

void* user_args);

/*! \brief Post-dispatch call back function signature

*

* This is the signature of the call back fuction after the kernel

* dispatch. The call back function is to indicate the completion of

* the the kernel launch. It is used by the debugger.

*/

typedef void* (*cl_PostDispatchCallBackFunctionAMD)(cl_device_id device, cl_ulong event,

void* user_args);

/*! \brief Set up the dispatch call back function pointers

*

* \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

*/

extern CL_API_ENTRY cl_int CL_API_CALL clHwDbgSetCallBackFunctionsAMD(

cl_device_id /* device */, cl_PreDispatchCallBackFunctionAMD /* preDispatchFunction */,

cl_PostDispatchCallBackFunctionAMD /* postDispatchFunction */

) CL_API_SUFFIX__VERSION_2_0;

/*! \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

*/

extern CL_API_ENTRY cl_int CL_API_CALL clHwDbgSetCallBackArgumentsAMD(cl_device_id /* device */,

void* /* preDispatchArgs */,

void* /* postDispatchArgs */

) CL_API_SUFFIX__VERSION_2_0;

/*! \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

*/

extern CL_API_ENTRY cl_int CL_API_CALL clHwDbgFlushCacheAMD(cl_device_id /* device */,

cl_dbg_gpu_cache_mask_amd /* mask */

) CL_API_SUFFIX__VERSION_2_0;

/*! \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

*/

extern CL_API_ENTRY cl_int CL_API_CALL clHwDbgSetExceptionPolicyAMD(

cl_device_id /* device */, cl_dbg_exception_policy_amd* /* policy */

) CL_API_SUFFIX__VERSION_2_0;

/*! \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

*/

extern CL_API_ENTRY cl_int CL_API_CALL clHwDbgGetExceptionPolicyAMD(

cl_device_id /* device */, cl_dbg_exception_policy_amd* /* policy */

) CL_API_SUFFIX__VERSION_2_0;

/*! \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

*/

extern CL_API_ENTRY cl_int CL_API_CALL clHwDbgSetKernelExecutionModeAMD(

cl_device_id /* device */, cl_dbg_kernel_exec_mode_amd* /* mode */

) CL_API_SUFFIX__VERSION_2_0;

/*! \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

*/

extern CL_API_ENTRY cl_int CL_API_CALL clHwDbgGetKernelExecutionModeAMD(

cl_device_id /* device */, cl_dbg_kernel_exec_mode_amd* /* mode */

) CL_API_SUFFIX__VERSION_2_0;

/*! \brief Create a debug event

*

* \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

*/

extern CL_API_ENTRY cl_int CL_API_CALL clHwDbgCreateEventAMD(cl_device_id /* device */,

bool /* autoReset */,

cl_dbg_event_amd* /* pDebugEvent */,

cl_uint* /* pEventId */

) CL_API_SUFFIX__VERSION_2_0;

/*! \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

*/

extern CL_API_ENTRY cl_int CL_API_CALL clHwDbgWaitEventAMD(cl_device_id /* device */,

cl_dbg_event_amd /* pDebugEvent */,

cl_uint /* pEventId */,

cl_uint /* timeOut */

) CL_API_SUFFIX__VERSION_2_0;

/*! \brief Destroy a debug event

*

* \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

*/

extern CL_API_ENTRY cl_int CL_API_CALL clHwDbgDestroyEventAMD(cl_device_id /* device */,

cl_dbg_event_amd* /* pDebugEvent */,

cl_uint* /* pEventId */

) CL_API_SUFFIX__VERSION_2_0;

/*! \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

*/

extern CL_API_ENTRY cl_int CL_API_CALL clHwDbgRegisterDebuggerAMD(

cl_context /* context */, cl_device_id /* device */, volatile void* /* pMessageStorage */

) CL_API_SUFFIX__VERSION_2_0;

/*! \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

*/

extern CL_API_ENTRY cl_int CL_API_CALL clHwDbgUnregisterDebuggerAMD(cl_device_id /* device */

) CL_API_SUFFIX__VERSION_2_0;

/*! \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

*/

extern CL_API_ENTRY cl_int CL_API_CALL clHwDbgSetAclBinaryAMD(cl_device_id /* device */,

void* /* aclBinary */

) CL_API_SUFFIX__VERSION_2_0;

/*! \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

*/

extern CL_API_ENTRY cl_int CL_API_CALL 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 */

) CL_API_SUFFIX__VERSION_2_0;

/*! \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

*/

extern CL_API_ENTRY cl_int CL_API_CALL 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 */

) CL_API_SUFFIX__VERSION_2_0;

/*! \brief Get the packaet information for kernel execution

*

* \param device specifies the device to be used

*

* \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

*/

extern CL_API_ENTRY cl_int CL_API_CALL clHwDbgGetAqlPacketInfoAMD(

cl_device_id /* device */, const void* /* aqlCodeInfo */,

cl_aql_packet_info_amd* /* packetInfo */

) CL_API_SUFFIX__VERSION_2_0;

/*! \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

*/

extern CL_API_ENTRY cl_int CL_API_CALL clHwDbgGetDispatchDebugInfoAMD(

cl_device_id /* device */, cl_dispatch_debug_info_amd* /* debugInfo */

) CL_API_SUFFIX__VERSION_2_0;

/*! \brief Map the video memory for the kernel code to allow host access

*

* \param device specifies the device to be used

*

* \param aqlCodeAddress is the memory points to the returned host memory address for the kernel

* code

*

* \param aqlCodeSize returns the size of 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

*/

extern CL_API_ENTRY cl_int CL_API_CALL clHwDbgMapKernelCodeAMD(cl_device_id /* device */,

void* /* aqlCodeInfo */

) CL_API_SUFFIX__VERSION_2_0;

/*! \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

*/

extern CL_API_ENTRY cl_int CL_API_CALL clHwDbgUnmapKernelCodeAMD(cl_device_id /* device */,

cl_ulong* /* aqlCodeAddress */

) CL_API_SUFFIX__VERSION_2_0;

/*! \brief Map the shader scratch ring's video 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

*/

extern CL_API_ENTRY cl_int CL_API_CALL clHwDbgMapScratchRingAMD(cl_device_id /* device */,

cl_ulong* /* scratchRingAddr */,

cl_uint* /* scratchRingSize */

) CL_API_SUFFIX__VERSION_2_0;

/*! \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

*/

extern CL_API_ENTRY cl_int CL_API_CALL clHwDbgUnmapScratchRingAMD(cl_device_id /* device */,

cl_ulong* /* scratchRingAddr */

) CL_API_SUFFIX__VERSION_2_0;

/*! \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

*/

extern CL_API_ENTRY cl_int CL_API_CALL clHwDbgGetKernelParamMemAMD(cl_device_id /* devicepointer */,

cl_uint /* paramIdx */,

cl_mem* /* paramMem */

) CL_API_SUFFIX__VERSION_2_0;

/*! \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

*/

extern CL_API_ENTRY cl_int CL_API_CALL clHwDbgSetGlobalMemoryAMD(cl_device_id /* device */,

cl_mem /* memObject */,

cl_uint /* offset */,

void* /* srcMem */,

cl_uint /* size */

) CL_API_SUFFIX__VERSION_2_0;

/*! \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)

*

* \param trapHandlerSize size (in bytes) of the trap handler

*

* \param trapBufferSize size (in bytes) of the trap handler buffer

*

* \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 trapHandler is NULL or trapHandlerSize <= 0

* - CL_HWDBG_MANAGER_NOT_AVAILABLE_AMD if there is no HW DEBUG manager

*/

extern CL_API_ENTRY cl_int CL_API_CALL clHwDbgInstallTrapAMD(cl_device_id /* device */,

cl_dbg_trap_type_amd /* trapType */,

cl_mem /* trapHandler */,

cl_mem /* trapBuffer */

) CL_API_SUFFIX__VERSION_2_0;

#ifdef __cplusplus

} /*extern "C"*/

#endif /*__cplusplus*/

#endif /*__CL_DEBUGGER_AMD_H*/