foreman
130 lines
4.9 KiB
C++
130 lines
4.9 KiB
C++
//
|
|
// Copyright (c) 2008 Advanced Micro Devices, Inc. All rights reserved.
|
|
//
|
|
|
|
#ifndef THREAD_TRACE_HPP_
|
|
#define THREAD_TRACE_HPP_
|
|
|
|
#include "top.hpp"
|
|
#include "device/device.hpp"
|
|
#include "amdocl/cl_thread_trace_amd.h"
|
|
|
|
|
|
namespace amd {
|
|
|
|
#define THREAD_TRACE_BUFFER_DEFAULT_SIZE 4096
|
|
|
|
/*! \addtogroup Runtime
|
|
* @{
|
|
*
|
|
* \addtogroup Threadtrace
|
|
* @{
|
|
*/
|
|
|
|
/*! \class ThreadTrace
|
|
*
|
|
* \brief The container class for the thread traces
|
|
*/
|
|
class ThreadTrace : public RuntimeObject
|
|
{
|
|
public:
|
|
enum State {
|
|
None,
|
|
MemoryBound,
|
|
Begin,
|
|
End,
|
|
Pause
|
|
};
|
|
typedef struct ThreadTraceConfigRec
|
|
{
|
|
size_t configSize_; // structure size
|
|
size_t cu_; // target compute unit [cu]
|
|
size_t sh_; // target shader array [sh],that contains target cu
|
|
size_t simdMask_; // bitmask to enable or disable target tokens for different SIMDs
|
|
size_t vmIdMask_; // virtual memory [vm] IDs to capture
|
|
size_t tokenMask_; // bitmask indicating which trace token IDs will be included in the trace
|
|
size_t regMask_; // bitmask indicating which register types should be included in the trace
|
|
size_t instMask_; // types of instruction scheduling updates which should be recorded
|
|
size_t randomSeed_; // linear feedback shift register [LFSR] seed
|
|
size_t userData_; // user data ,which is written as payload
|
|
size_t captureMode_; // indicator for the way how THREAD_TRACE_START / STOP events affect token collection
|
|
bool isUserData_; // indicator if user_data is set
|
|
bool isWrapped_; // indicator if the memory buffer should be wrapped around instead of stopping at the end
|
|
//default thread trace configuration/s initializator
|
|
ThreadTraceConfigRec():configSize_(0),cu_(0),sh_(0),simdMask_(0xF),vmIdMask_(CL_THREAD_TRACE_VM_ID_MASK_SINGLE),
|
|
tokenMask_(CL_THREAD_TRACE_TOKEN_MASK_ALL_SI),regMask_(CL_THREAD_TRACE_REG_MASK_ALL_SI),
|
|
instMask_(CL_THREAD_TRACE_INST_MASK_ALL),randomSeed_(0xFFF),userData_(0),
|
|
captureMode_(CL_THREAD_TRACE_CAPTURE_ALL),isUserData_(false),isWrapped_(false){
|
|
configSize_ = sizeof(struct ThreadTraceConfigRec);
|
|
}
|
|
}ThreadTraceConfig;
|
|
|
|
//! Constructor of the thread trace object
|
|
ThreadTrace(
|
|
const Device& device) //!< device object
|
|
: deviceThreadTrace_(NULL)
|
|
,device_(device)
|
|
,state_(None)
|
|
{ }
|
|
|
|
//! Get the thread trace's associated device
|
|
const Device& device() const { return device_; }
|
|
|
|
//! Get the shader engines number for thread trace`s associated device
|
|
const size_t deviceSeNumThreadTrace() const { return device_.info().numberOfShaderEngines; }
|
|
|
|
//! Get the device thread trace
|
|
device::ThreadTrace* getDeviceThreadTrace() { return deviceThreadTrace_; }
|
|
|
|
//! Set the device thread trace
|
|
void setDeviceThreadTrace(device::ThreadTrace* threadTrace) { deviceThreadTrace_ = threadTrace; }
|
|
|
|
void setState(State state) {state_ = state;}
|
|
State getState() {return state_;}
|
|
|
|
void setCU(unsigned int cu) { threadTraceConfig_.cu_ = cu; }
|
|
|
|
void setSH(unsigned int sh) { threadTraceConfig_.sh_ = sh; }
|
|
|
|
void setSIMD(unsigned int simdMask) { threadTraceConfig_.simdMask_ = simdMask; }
|
|
|
|
void setUserData(unsigned int userData) {
|
|
threadTraceConfig_.isUserData_ = true;
|
|
threadTraceConfig_.userData_ = userData;
|
|
}
|
|
|
|
void setTokenMask(unsigned int tokenMask) { threadTraceConfig_.tokenMask_ = tokenMask; }
|
|
|
|
void setRegMask(unsigned int regMask) { threadTraceConfig_.regMask_ = regMask; }
|
|
|
|
void setVmIdMask(unsigned int vmIdMask) { threadTraceConfig_.vmIdMask_ = vmIdMask; }
|
|
|
|
void setInstMask(unsigned int instMask) { threadTraceConfig_.instMask_ = instMask; }
|
|
|
|
void setRandomSeed(unsigned int randomSeed) { threadTraceConfig_.randomSeed_ = randomSeed; }
|
|
|
|
void setCaptureMode(unsigned int captureMode) { threadTraceConfig_.captureMode_ = captureMode; }
|
|
|
|
void setIsWrapped(bool isWrapped) { threadTraceConfig_.isWrapped_ = isWrapped; }
|
|
|
|
const ThreadTraceConfig& threadTraceConfig() const {return threadTraceConfig_;}
|
|
|
|
//! RTTI internal implementation
|
|
virtual ObjectType objectType() const {return ObjectTypeThreadTrace;}
|
|
protected:
|
|
//! Destructor for ThreadTrace class
|
|
~ThreadTrace() {
|
|
delete deviceThreadTrace_;
|
|
}
|
|
|
|
device::ThreadTrace* deviceThreadTrace_; //!< device thread trace object
|
|
const Device& device_; //!< the device object
|
|
State state_;
|
|
ThreadTraceConfig threadTraceConfig_;
|
|
};
|
|
|
|
/*@}*/
|
|
/*@}*/ } // namespace amd
|
|
|
|
#endif // THREAD_TRACE_HPP_
|