440 строки
22 KiB
C
440 строки
22 KiB
C
/* ============================================================
|
|
|
|
Copyright (c) 2012 Advanced Micro Devices, Inc. All rights reserved.
|
|
|
|
Redistribution and use of this material is permitted under the following
|
|
conditions:
|
|
|
|
Redistributions must retain the above copyright notice and all terms of this
|
|
license.
|
|
|
|
In no event shall anyone redistributing or accessing or using this material
|
|
commence or participate in any arbitration or legal action relating to this
|
|
material against Advanced Micro Devices, Inc. or any copyright holders or
|
|
contributors. The foregoing shall survive any expiration or termination of
|
|
this license or any agreement or access or use related to this material.
|
|
|
|
ANY BREACH OF ANY TERM OF THIS LICENSE SHALL RESULT IN THE IMMEDIATE REVOCATION
|
|
OF ALL RIGHTS TO REDISTRIBUTE, ACCESS OR USE THIS MATERIAL.
|
|
|
|
THIS MATERIAL IS PROVIDED BY ADVANCED MICRO DEVICES, INC. AND ANY COPYRIGHT
|
|
HOLDERS AND CONTRIBUTORS "AS IS" IN ITS CURRENT CONDITION AND WITHOUT ANY
|
|
REPRESENTATIONS, GUARANTEE, OR WARRANTY OF ANY KIND OR IN ANY WAY RELATED TO
|
|
SUPPORT, INDEMNITY, ERROR FREE OR UNINTERRUPTED OPERATION, OR THAT IT IS FREE
|
|
FROM DEFECTS OR VIRUSES. ALL OBLIGATIONS ARE HEREBY DISCLAIMED - WHETHER
|
|
EXPRESS, IMPLIED, OR STATUTORY - INCLUDING, BUT NOT LIMITED TO, ANY IMPLIED
|
|
WARRANTIES OF TITLE, MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE,
|
|
ACCURACY, COMPLETENESS, OPERABILITY, QUALITY OF SERVICE, OR NON-INFRINGEMENT.
|
|
IN NO EVENT SHALL ADVANCED MICRO DEVICES, INC. OR ANY COPYRIGHT HOLDERS OR
|
|
CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, PUNITIVE,
|
|
EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT
|
|
OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, REVENUE, DATA, OR PROFITS; OR
|
|
BUSINESS INTERRUPTION) HOWEVER CAUSED OR BASED ON ANY THEORY OF LIABILITY
|
|
ARISING IN ANY WAY RELATED TO THIS MATERIAL, EVEN IF ADVISED OF THE POSSIBILITY
|
|
OF SUCH DAMAGE. THE ENTIRE AND AGGREGATE LIABILITY OF ADVANCED MICRO DEVICES,
|
|
INC. AND ANY COPYRIGHT HOLDERS AND CONTRIBUTORS SHALL NOT EXCEED TEN DOLLARS
|
|
(US $10.00). ANYONE REDISTRIBUTING OR ACCESSING OR USING THIS MATERIAL ACCEPTS
|
|
THIS ALLOCATION OF RISK AND AGREES TO RELEASE ADVANCED MICRO DEVICES, INC. AND
|
|
ANY COPYRIGHT HOLDERS AND CONTRIBUTORS FROM ANY AND ALL LIABILITIES,
|
|
OBLIGATIONS, CLAIMS, OR DEMANDS IN EXCESS OF TEN DOLLARS (US $10.00). THE
|
|
FOREGOING ARE ESSENTIAL TERMS OF THIS LICENSE AND, IF ANY OF THESE TERMS ARE
|
|
CONSTRUED AS UNENFORCEABLE, FAIL IN ESSENTIAL PURPOSE, OR BECOME VOID OR
|
|
DETRIMENTAL TO ADVANCED MICRO DEVICES, INC. OR ANY COPYRIGHT HOLDERS OR
|
|
CONTRIBUTORS FOR ANY REASON, THEN ALL RIGHTS TO REDISTRIBUTE, ACCESS OR USE
|
|
THIS MATERIAL SHALL TERMINATE IMMEDIATELY. MOREOVER, THE FOREGOING SHALL
|
|
SURVIVE ANY EXPIRATION OR TERMINATION OF THIS LICENSE OR ANY AGREEMENT OR
|
|
ACCESS OR USE RELATED TO THIS MATERIAL.
|
|
|
|
NOTICE IS HEREBY PROVIDED, AND BY REDISTRIBUTING OR ACCESSING OR USING THIS
|
|
MATERIAL SUCH NOTICE IS ACKNOWLEDGED, THAT THIS MATERIAL MAY BE SUBJECT TO
|
|
RESTRICTIONS UNDER THE LAWS AND REGULATIONS OF THE UNITED STATES OR OTHER
|
|
COUNTRIES, WHICH INCLUDE BUT ARE NOT LIMITED TO, U.S. EXPORT CONTROL LAWS SUCH
|
|
AS THE EXPORT ADMINISTRATION REGULATIONS AND NATIONAL SECURITY CONTROLS AS
|
|
DEFINED THEREUNDER, AS WELL AS STATE DEPARTMENT CONTROLS UNDER THE U.S.
|
|
MUNITIONS LIST. THIS MATERIAL MAY NOT BE USED, RELEASED, TRANSFERRED, IMPORTED,
|
|
EXPORTED AND/OR RE-EXPORTED IN ANY MANNER PROHIBITED UNDER ANY APPLICABLE LAWS,
|
|
INCLUDING U.S. EXPORT CONTROL LAWS REGARDING SPECIFICALLY DESIGNATED PERSONS,
|
|
COUNTRIES AND NATIONALS OF COUNTRIES SUBJECT TO NATIONAL SECURITY CONTROLS.
|
|
MOREOVER, THE FOREGOING SHALL SURVIVE ANY EXPIRATION OR TERMINATION OF ANY
|
|
LICENSE OR AGREEMENT OR ACCESS OR USE RELATED TO THIS MATERIAL.
|
|
|
|
NOTICE REGARDING THE U.S. GOVERNMENT AND DOD AGENCIES: This material is
|
|
provided with "RESTRICTED RIGHTS" and/or "LIMITED RIGHTS" as applicable to
|
|
computer software and technical data, respectively. Use, duplication,
|
|
distribution or disclosure by the U.S. Government and/or DOD agencies is
|
|
subject to the full extent of restrictions in all applicable regulations,
|
|
including those found at FAR52.227 and DFARS252.227 et seq. and any successor
|
|
regulations thereof. Use of this material by the U.S. Government and/or DOD
|
|
agencies is acknowledgment of the proprietary rights of any copyright holders
|
|
and contributors, including those of Advanced Micro Devices, Inc., as well as
|
|
the provisions of FAR52.227-14 through 23 regarding privately developed and/or
|
|
commercial computer software.
|
|
|
|
This license forms the entire agreement regarding the subject matter hereof and
|
|
supersedes all proposals and prior discussions and writings between the parties
|
|
with respect thereto. This license does not affect any ownership, rights, title,
|
|
or interest in, or relating to, this material. No terms of this license can be
|
|
modified or waived, and no breach of this license can be excused, unless done
|
|
so in a writing signed by all affected parties. Each term of this license is
|
|
separately enforceable. If any term of this license is determined to be or
|
|
becomes unenforceable or illegal, such term shall be reformed to the minimum
|
|
extent necessary in order for this license to remain in effect in accordance
|
|
|
|
with its terms as modified by such reformation. This license shall be governed
|
|
by and construed in accordance with the laws of the State of Texas without
|
|
regard to rules on conflicts of law of any state or jurisdiction or the United
|
|
Nations Convention on the International Sale of Goods. All disputes arising out
|
|
of this license shall be subject to the jurisdiction of the federal and state
|
|
courts in Austin, Texas, and all defenses are hereby waived concerning personal
|
|
jurisdiction and venue of these courts.
|
|
|
|
============================================================ */
|
|
|
|
#ifndef __CL_THREAD_TRACE_AMD_H
|
|
#define __CL_THREAD_TRACE_AMD_H
|
|
|
|
#include "CL/cl_platform.h"
|
|
|
|
#ifdef __cplusplus
|
|
extern "C" {
|
|
#endif /*__cplusplus*/
|
|
|
|
typedef struct _cl_threadtrace_amd * cl_threadtrace_amd;
|
|
typedef cl_uint cl_thread_trace_param;
|
|
typedef cl_uint cl_threadtrace_info;
|
|
|
|
/* cl_command_type */
|
|
#define CL_COMMAND_THREAD_TRACE_MEM 0x4500
|
|
#define CL_COMMAND_THREAD_TRACE 0x4501
|
|
|
|
/* cl_threadtrace_command_name_amd enumeration */
|
|
typedef enum _cl_threadtrace_command_name_amd {
|
|
CL_THREAD_TRACE_BEGIN_COMMAND,
|
|
CL_THREAD_TRACE_END_COMMAND,
|
|
CL_THREAD_TRACE_PAUSE_COMMAND,
|
|
CL_THREAD_TRACE_RESUME_COMMAND
|
|
} cl_threadtrace_command_name_amd;
|
|
|
|
// Thread trace parameters
|
|
enum ThreadTraceParameter
|
|
{
|
|
CL_THREAD_TRACE_PARAM_TOKEN_MASK,
|
|
CL_THREAD_TRACE_PARAM_REG_MASK,
|
|
CL_THREAD_TRACE_PARAM_COMPUTE_UNIT_TARGET,
|
|
CL_THREAD_TRACE_PARAM_SHADER_ARRAY_TARGET,
|
|
CL_THREAD_TRACE_PARAM_SIMD_MASK,
|
|
CL_THREAD_TRACE_PARAM_VM_ID_MASK,
|
|
CL_THREAD_TRACE_PARAM_RANDOM_SEED,
|
|
CL_THREAD_TRACE_PARAM_CAPTURE_MODE,
|
|
CL_THREAD_TRACE_PARAM_INSTRUCTION_MASK,
|
|
CL_THREAD_TRACE_PARAM_USER_DATA,
|
|
CL_THREAD_TRACE_PARAM_IS_WRAPPED
|
|
};
|
|
|
|
// CL_THREAD_TRACE_PARAM_TOKEN_MASK data selects for SI
|
|
enum CL_THREAD_TRACE_TOKEN_MASK
|
|
{
|
|
//Time passed
|
|
CL_THREAD_TRACE_TOKEN_MASK_TIME_SI = 0x00000001,
|
|
//Resync the timestamp
|
|
CL_THREAD_TRACE_TOKEN_MASK_TIMESTAMP_SI = 0x00000002,
|
|
//A register write has occurred
|
|
CL_THREAD_TRACE_TOKEN_MASK_REG_SI = 0x00000004,
|
|
//A wavefront has started
|
|
CL_THREAD_TRACE_TOKEN_MASK_WAVE_START_SI = 0x00000008,
|
|
//Output space has been allocated for color/Z [Should be used for cl-gl]
|
|
CL_THREAD_TRACE_TOKEN_MASK_WAVE_PS_ALLOC_SI = 0x00000010,
|
|
//Output space has been allocated for vertex position [Should be used for cl-gl]
|
|
CL_THREAD_TRACE_TOKEN_MASK_WAVE_VS_ALLOC_SI = 0x00000020,
|
|
//Wavefront completion
|
|
CL_THREAD_TRACE_TOKEN_MASK_WAVE_END_SI = 0x00000040,
|
|
//An event has reached the top of a shader stage. In-order with WAVE_START
|
|
CL_THREAD_TRACE_TOKEN_MASK_EVENT_SI = 0x00000080,
|
|
//An event has reached the top of a compute shader stage. In-order with WAVE_START
|
|
CL_THREAD_TRACE_TOKEN_MASK_EVENT_CS_SI = 0x00000100,
|
|
//An event has reached the top of a shader stage for the second GFX pipe. In-order with WAVE_START.
|
|
//[Should be used for cl-gl]
|
|
CL_THREAD_TRACE_TOKEN_MASK_EVENT_GFX_SI = 0x00000200,
|
|
//The kernel has executed an instruction
|
|
CL_THREAD_TRACE_TOKEN_MASK_INST_SI = 0x00000400,
|
|
//The kernel has explicitly written the PC value
|
|
CL_THREAD_TRACE_TOKEN_MASK_INST_PC_SI = 0x00000800,
|
|
//The kernel has written user data into the thread trace buffer
|
|
CL_THREAD_TRACE_TOKEN_MASK_INST_USERDATA_SI = 0x00001000,
|
|
//Provides information about instruction scheduling
|
|
CL_THREAD_TRACE_TOKEN_MASK_ISSUE_SI = 0x00002000,
|
|
//The performance counter delta has been updated
|
|
CL_THREAD_TRACE_TOKEN_MASK_PERF_SI = 0x00004000,
|
|
//A miscellaneous event has been sent
|
|
CL_THREAD_TRACE_TOKEN_MASK_MISC_SI = 0x00008000,
|
|
//All possible tokens
|
|
CL_THREAD_TRACE_TOKEN_MASK_ALL_SI = 0x0000ffff,
|
|
};
|
|
|
|
//CL_THREAD_TRACE_PARAM_REG_MASK data selects
|
|
enum CL_THREAD_TRACE_REG_MASK
|
|
{
|
|
//Event initiator
|
|
CL_THREAD_TRACE_REG_MASK_EVENT_SI = 0x00000001,
|
|
//Draw initiator [Should be used for cl-gl]
|
|
CL_THREAD_TRACE_REG_MASK_DRAW_SI = 0x00000002,
|
|
//Dispatch initiator
|
|
CL_THREAD_TRACE_REG_MASK_DISPATCH_SI = 0x00000004,
|
|
//User data from host
|
|
CL_THREAD_TRACE_REG_MASK_USERDATA_SI = 0x00000008,
|
|
//GFXDEC register (8-state) [Should be used for cl-gl]
|
|
CL_THREAD_TRACE_REG_MASK_GFXDEC_SI = 0x00000020,
|
|
//SHDEC register (many state)
|
|
CL_THREAD_TRACE_REG_MASK_SHDEC_SI = 0x00000040,
|
|
//Other registers
|
|
CL_THREAD_TRACE_REG_MASK_OTHER_SI = 0x00000080,
|
|
//All possible registers types
|
|
CL_THREAD_TRACE_REG_MASK_ALL_SI = 0x000000ff,
|
|
};
|
|
|
|
//CL_THREAD_TRACE_PARAM_VM_ID_MASK data selects
|
|
enum CL_THREAD_TRACE_VM_ID_MASK
|
|
{
|
|
//Capture only data from the VM_ID used to write {SQTT}_BASE
|
|
CL_THREAD_TRACE_VM_ID_MASK_SINGLE = 0,
|
|
//Capture all data from all VM_IDs
|
|
CL_THREAD_TRACE_VM_ID_MASK_ALL = 1,
|
|
//Capture all data but only get target (a.k.a. detail) data from VM_ID used to write {SQTT}_BASE
|
|
CL_THREAD_TRACE_VM_ID_MASK_SINGLE_DETAIL = 2
|
|
};
|
|
|
|
//CL_THREAD_TRACE_PARAM_CAPTURE_MODE data
|
|
enum CL_THREAD_TRACE_CAPTURE_MODE
|
|
{
|
|
//Capture all data in the thread trace buffer
|
|
CL_THREAD_TRACE_CAPTURE_ALL = 0,
|
|
//Capture only data between THREAD_TRACE_START and THREAD_TRACE_STOP events
|
|
CL_THREAD_TRACE_CAPTURE_SELECT = 1,
|
|
//Capture data between THREAD_TRACE_START and THREAD_TRACE_/STOP events,
|
|
//and global/reference data at all times
|
|
CL_THREAD_TRACE_CAPTURE_SELECT_DETAIL = 2
|
|
};
|
|
|
|
//CL_THREAD_TRACE_PARAM_INSTRUCTION_MASK data selects
|
|
enum CL_THREAD_TRACE_INSTRUCTION_MASK
|
|
{
|
|
//Generate {SQTT}_TOKEN_INST tokens for all instructions
|
|
CL_THREAD_TRACE_INST_MASK_ALL,
|
|
//Generate {SQTT}_TOKEN_INST tokens for stalled instructions only
|
|
CL_THREAD_TRACE_INST_MASK_STALLED,
|
|
//Generate {SQTT}_TOKEN_INST messages for stalled and other (no op/wait/set prio/etc) instructions
|
|
CL_THREAD_TRACE_INST_MASK_STALLED_AND_IMMEDIATE,
|
|
//Generate {SQTT}_TOKEN_INST messages for immediate instructions only only [ Should be used only for CI]
|
|
CL_THREAD_TRACE_INST_MASK_IMMEDIATE_CI,
|
|
};
|
|
|
|
enum ThreadTraceInfo
|
|
{
|
|
CL_THREAD_TRACE_SE,
|
|
CL_THREAD_TRACE_BUFFERS_FILLED,
|
|
CL_THREAD_TRACE_BUFFERS_SIZE
|
|
};
|
|
|
|
|
|
/*! \brief Creates a new cl_threadtrace_amd object
|
|
*
|
|
* \param device must be a valid OpenCL device.
|
|
*
|
|
* \param errcode_ret A non zero value if OpenCL failed to create threadTrace
|
|
* -CL_INVALID_DEVICE if devices contains an invalid device.
|
|
* -CL_DEVICE_NOT_AVAILABLE if a device is currently not available even
|
|
* though the device was returned by clGetDeviceIDs.
|
|
* -CL_OUT_OF_RESOURCES if there is a failure to allocate resources required by the
|
|
* OpenCL implementation on the device.
|
|
* -CL_OUT_OF_HOST_MEMORY if there is a failure to allocate resources required by the
|
|
OpenCL implementation on the host.
|
|
*
|
|
* \return the created threadTrace object
|
|
*/
|
|
extern CL_API_ENTRY cl_threadtrace_amd CL_API_CALL
|
|
clCreateThreadTraceAMD(
|
|
cl_device_id /* device */,
|
|
cl_int* /* errcode_ret */
|
|
) CL_API_SUFFIX__VERSION_1_0;
|
|
|
|
/*! \brief Destroys a cl_threadtrace_amd object.
|
|
*
|
|
* \param threadTrace the cl_threadtrace_amd object for release
|
|
*
|
|
* \return A non zero value if OpenCL failed to release threadTrace
|
|
* -CL_INVALID_VALUE if the thread_trace is not a valid OpenCL thread trace object (cl_threadtrace_amd) .
|
|
* -CL_OUT_OF_RESOURCES if there is a failure to allocate resources required by the
|
|
* OpenCL implementation on the device.
|
|
* -CL_OUT_OF_HOST_MEMORY if there is a failure to allocate resources required by the
|
|
OpenCL implementation on the host.
|
|
*/
|
|
extern CL_API_ENTRY cl_int CL_API_CALL
|
|
clReleaseThreadTraceAMD(
|
|
cl_threadtrace_amd /* threadTrace */
|
|
) CL_API_SUFFIX__VERSION_1_0;
|
|
|
|
/*! \brief Increments the cl_threadtrace_amd object reference count.
|
|
*
|
|
* \param threadTrace the cl_threadtrace_amd object for retain
|
|
*
|
|
* \return A non zero value if OpenCL failed to retain threadTrace
|
|
* -CL_INVALID_VALUE if the thread_trace is not a valid thread trace object (cl_threadtrace_amd) .
|
|
* -CL_OUT_OF_RESOURCES if there is a failure to allocate resources required by the
|
|
OpenCL implementation on the device.
|
|
* -CL_OUT_OF_HOST_MEMORY if there is a failure to allocate resources required by the
|
|
OpenCL implementation on the host.
|
|
*/
|
|
extern CL_API_ENTRY cl_int CL_API_CALL
|
|
clRetainThreadTraceAMD(
|
|
cl_threadtrace_amd /* threadTrace */
|
|
) CL_API_SUFFIX__VERSION_1_0;
|
|
|
|
/*! \brief Sets the cl_threadtrace_amd object configuration parameter.
|
|
*
|
|
* \param thread_trace the cl_threadtrace_amd object to set configuration parameter
|
|
*
|
|
* \param config_param the cl_thread_trace_param
|
|
*
|
|
* \param param_value corresponding to configParam
|
|
*
|
|
* \return A non zero value if OpenCL failed to set threadTrace buffer parameter
|
|
* - CL_INVALID_VALUE if the thread_trace is invalid thread trace object.
|
|
* - CL_INVALID_VALUE if the invalid config_param or param_value enum values , are used.
|
|
* - CL_INVALID_EVENT_WAIT_LIST if event_wait_list is NULL and num_events_in_wait_list > 0, or event_wait_list is not NULL and num_events_in_wait_list is 0,
|
|
* - or if event objects in event_wait_list are not valid events.
|
|
* - CL_OUT_OF_RESOURCES if there is a failure to allocate resources required by the OpenCL implementation on the device.
|
|
* - CL_OUT_OF_HOST_MEMORY if there is a failure to allocate resources required by the
|
|
OpenCL implementation on the host.
|
|
*/
|
|
|
|
extern CL_API_ENTRY cl_int CL_API_CALL
|
|
clSetThreadTraceParamAMD(cl_threadtrace_amd /*thread_trace*/ ,
|
|
cl_thread_trace_param /*config_param*/ ,
|
|
cl_uint /*param_value*/
|
|
)CL_API_SUFFIX__VERSION_1_0;
|
|
|
|
/* \brief Enqueues the binding command to bind cl_threadtrace_amd to cl_mem object for trace recording..
|
|
*
|
|
* \param command_queue must be a valid OpenCL command queue.
|
|
*
|
|
* \param thread_trace specifies the cl_threadtrace_amd object.
|
|
*
|
|
* \param mem_objects the cl_mem objects for trace recording
|
|
*
|
|
* \param mem_objects_num the number of cl_mem objects in the mem_objects
|
|
*
|
|
* \param buffer_size the size of each cl_mem object from mem_objects
|
|
*
|
|
* \param event_wait_list specify [is a pointer to] events that need to
|
|
* complete before this particular command can be executed.
|
|
* If \a event_wait_list is NULL, then this particular command does not wait
|
|
* on any event to complete. If \a event_wait_list is NULL,
|
|
* \a num_events_in_wait_list must be 0. If \a event_wait_list is not NULL,
|
|
* the list of events pointed to by \a event_wait_list must be valid and
|
|
* \a num_events_in_wait_list must be greater than 0. The events specified in
|
|
* \a event_wait_list act as synchronization points.
|
|
*
|
|
* \param num_events_in_wait_list specify the number of events in
|
|
* \a event_wait_list. It must be 0 if \a event_wait_list is NULL. It must be
|
|
* greater than 0 if \a event_wait_list is not NULL.
|
|
*
|
|
* \param event returns an event object that identifies this particular
|
|
* command and can be used to query or queue a wait for this particular
|
|
* command to complete. \a event can be NULL in which case it will not be
|
|
* possible for the application to query the status of this command or queue a
|
|
* wait for this command to complete.
|
|
* \return A non zero value if OpenCL failed to set threadTrace buffer parameter
|
|
* - CL_INVALID_COMMAND_QUEUE if command_queue is not a valid command-queue.
|
|
* - CL_INVALID_CONTEXT if the context associated with command_queue and events in event_wait_list are not the same.
|
|
* - CL_INVALID_VALUE if the thread_trace is invalid thread trace object.
|
|
* - CL_INVALID_VALUE if the buffer_size is negative or zero.
|
|
* - CL_INVALID_VALUE if the sub_buffers_num I less than 1.
|
|
* - CL_INVALID_OPERATION if the mem_objects_num is not equal to the number of Shader Engines of the [GPU] device.
|
|
* - CL_INVALID_MEM_OBJECT if one on memory objects in the mem_objects array is not a valid memory object or memory_objects is NULL.
|
|
* - CL_MEM_OBJECT_ALLOCATION_FAILURE if there is a failure to allocate memory for the data store associated from the memory objects of the mem_objects array.
|
|
* - CL_INVALID_EVENT_WAIT_LIST if event_wait_list is NULL and num_events_in_wait_list > 0, or event_wait_list is not NULL and num_events_in_wait_list is 0, or if event objects in event_wait_list are not valid events.
|
|
* - CL_OUT_OF_RESOURCES if there is a failure to allocate resources required by the OpenCL implementation on the device.
|
|
* - CL_OUT_OF_HOST_MEMORY if there is a failure to allocate resources required by the
|
|
* OpenCL implementation on the host.
|
|
*/
|
|
extern CL_API_ENTRY cl_int CL_API_CALL
|
|
clEnqueueBindThreadTraceBufferAMD(cl_command_queue command_queue ,
|
|
cl_threadtrace_amd /*thread_trace*/ ,
|
|
cl_mem* /*mem_objects*/ ,
|
|
cl_uint /*mem_objects_num*/ ,
|
|
cl_uint /*buffer_size*/ ,
|
|
cl_uint /*num_events_in_wait_list*/ ,
|
|
const cl_event* /*event_wait_list*/ ,
|
|
cl_event* /*event*/
|
|
) CL_API_SUFFIX__VERSION_1_0;
|
|
|
|
/*! \brief Get specific information about the OpenCL Thread Trace.
|
|
*
|
|
* \param thread_trace_info_param is an enum that identifies the Thread Trace information being
|
|
* queried.
|
|
*
|
|
* \param param_value is a pointer to memory location where appropriate values
|
|
* for a given \a threadTrace_info_param will be returned. If \a param_value is NULL,
|
|
* it is ignored.
|
|
*
|
|
* \param param_value_size specifies the size in bytes of memory pointed to by
|
|
* \a param_value. This size in bytes must be >= size of return type.
|
|
*
|
|
* \param param_value_size_ret returns the actual size in bytes of data being
|
|
* queried by param_value. If \a param_value_size_ret is NULL, it is ignored.
|
|
*
|
|
* \return One of the following values:
|
|
* CL_INVALID_OPERATION if cl_threadtrace_amd object is not valid
|
|
* - CL_INVALID_VALUE if \a param_name is not one of the supported
|
|
* values or if size in bytes specified by \a param_value_size is < size of
|
|
* return type and \a param_value is not a NULL value.
|
|
* CL_OUT_OF_HOST_MEMORY if there is a failure to allocate resources required by the
|
|
* OpenCL implementation on the host.
|
|
* CL_SUCCESS if the function is executed successfully.
|
|
*/
|
|
extern CL_API_ENTRY cl_int CL_API_CALL
|
|
clGetThreadTraceInfoAMD(
|
|
cl_threadtrace_amd /* thread_trace */,
|
|
cl_threadtrace_info /*thread_trace_info_param*/,
|
|
size_t /*param_value_size*/,
|
|
void* /*param_value*/,
|
|
size_t* /*param_value_size_ret*/
|
|
) CL_API_SUFFIX__VERSION_1_0;
|
|
|
|
/*! \brief Enqueues the thread trace command for the specified thread trace object.
|
|
*
|
|
* \param command_queue must be a valid OpenCL command queue.
|
|
*
|
|
* \param threadTraces specifies an array of cl_threadtrace_amd objects.
|
|
*
|
|
* \return A non zero value if OpenCL failed to release threadTrace
|
|
* - CL_INVALID_COMMAND_QUEUE if command_queue is not a valid command-queue.
|
|
* - CL_INVALID_CONTEXT if the context associated with command_queue and events in event_wait_list are not the same.
|
|
* - CL_INVALID_VALUE if the thread_trace is invalid thread trace object .
|
|
* - CL_INVALID_VALUE if the invalid command name enum value , not described in the cl_threadtrace_command_name_amd, is used.
|
|
* - CL_INVALID_OPERATION if the command enqueue failed. It can happen in the following cases:
|
|
* o BEGIN_COMMAND is queued for thread trace object for which memory object/s was/were not bound..
|
|
* o END_COMMAND is queued for thread trace object, for which BEGIN_COMMAND was not queued.
|
|
* o PAUSE_COMMAND is queued for thread trace object, for which BEGIN_COMMAND was not queued.
|
|
* o RESUME_COMMAND is queued for thread trace object, for which PAUSE_COMMAND was not queued.
|
|
* - CL_INVALID_EVENT_WAIT_LIST if event_wait_list is NULL and num_events_in_wait_list > 0, or event_wait_list is not NULL and num_events_in_wait_list is 0, or if event objects in event_wait_list are not valid events.
|
|
* - CL_OUT_OF_RESOURCES if there is a failure to allocate resources required by the OpenCL implementation on the device.
|
|
* - CL_OUT_OF_HOST_MEMORY if there is a failure to allocate resources required by the OpenCL implementation on the host.
|
|
*/
|
|
extern CL_API_ENTRY cl_int CL_API_CALL
|
|
clEnqueueThreadTraceCommandAMD(
|
|
cl_command_queue /*command_queue*/ ,
|
|
cl_threadtrace_amd /*thread_trace*/ ,
|
|
cl_threadtrace_command_name_amd /*command_name*/ ,
|
|
cl_uint /*num_events_in_wait_list*/ ,
|
|
const cl_event* /*event_wait_list*/,
|
|
cl_event* /*event*/
|
|
)CL_API_SUFFIX__VERSION_1_0;
|
|
|
|
|
|
#ifdef __cplusplus
|
|
} /*extern "C"*/
|
|
#endif /*__cplusplus*/
|
|
|
|
#endif /*__CL_THREAD_TRACE_AMD_H*/
|