rocm-systems/rocclr/runtime/device/gpu/gputhreadtrace.hpp

//
// Copyright (c) 2009 Advanced Micro Devices, Inc. All rights reserved.
//
#ifndef GPU_THREAD_TRACE_HPP_
#define GPU_THREAD_TRACE_HPP_

#include "top.hpp"
#include "device/device.hpp"
#include "device/gpu/gpudevice.hpp"

#include <vector>
namespace gpu {

class VirtualGPU;

class CalThreadTraceReference : public amd::ReferenceCountedObject
{
public:
    //! Default constructor
    CalThreadTraceReference(
        VirtualGPU&     gpu,             //!< Virtual GPU device object
        gslQueryObject  gslThreadTrace)  //!< GSL query thread trace object
        : gpu_(gpu)
        , threadTrace_(gslThreadTrace){}

    //! Get GSL thread race object
    gslQueryObject gslThreadTrace() const { return threadTrace_; }

    //! Returns the virtual GPU device
    const VirtualGPU& gpu() const { return gpu_; }

protected:
    //! Default destructor
    ~CalThreadTraceReference();

private:
    //! Disable copy constructor
    CalThreadTraceReference(const CalThreadTraceReference&);

    //! Disable operator=
    CalThreadTraceReference& operator=(const CalThreadTraceReference&);

    VirtualGPU&     gpu_;           //!< The virtual GPU device object
    gslQueryObject  threadTrace_;   //!< GSL thread trace query object
};

//! ThreadTrace implementation on GPU
class ThreadTrace : public device::ThreadTrace
{
public:

    //! Destructor for the GPU ThreadTrace object
    virtual ~ThreadTrace();

    //! Creates the current object
    bool create(
        CalThreadTraceReference* calRef     //!< Reference ThreadTrace
        );

    //! Returns the GPU device, associated with the current object
    const Device& dev() const { return gpuDevice_; }

    //! Returns the virtual GPU device
    const VirtualGPU& gpu() const { return gpu_; }

    //! Constructor for the GPU ThreadTrace object
    ThreadTrace(
        Device&             device,               //!< A GPU device object
        VirtualGPU&         gpu,                   //!< Virtual GPU device object
        uint                amdThreadTraceMemObjsNum)
        : gpuDevice_(device)
        , gpu_(gpu)
        , calRef_(NULL)
        , index_(0)
        , amdThreadTraceMemObjsNum_(amdThreadTraceMemObjsNum)
    {
        threadTraceBufferObjs_ = new gslShaderTraceBufferObject[amdThreadTraceMemObjsNum];
        for (uint i = 0; i < amdThreadTraceMemObjsNum;++i) {
            threadTraceBufferObjs_[i] = gpu.CreateThreadTraceBuffer();
        }
    }

    //! Returns the specific information about the thread trace object
    bool info(
        uint infoType,   //!< The type of returned information
        uint* info,      //!< The returned information
        uint  infoSize   //!< The size of returned information
        ) const;

    //! Set the ThreadTrace memory buffer size
    void setMemBufferSizeTT(uint memBufferSizeTT) { memBufferSizeTT_ = memBufferSizeTT;}

    //! Set isNewBufferBinded_ to true/false if new buffer was binded/unbinded respectively
    void setNewBufferBinded(bool isNewBufferBinded) { isNewBufferBinded_ = isNewBufferBinded; }

    //! Attach gslMemObject to the TreadTrace buffer
    void attachMemToThreadTraceBuffer();

    void setMemObj(size_t memObjSize,std::vector<amd::Memory*> memObj)
    {
        memObj_ = memObj;
        memBufferSizeTT_ = memObjSize;
    }
    //! Get GSL thread trace object
    gslQueryObject gslThreadTrace() const { return threadTrace_; }

    //! Get GSL Thread Trace Buffer objects
    gslShaderTraceBufferObject* getThreadTraceBufferObjects() {return threadTraceBufferObjs_;}
private:
    //! Disable default copy constructor
    ThreadTrace(const ThreadTrace&);

    //! Disable default operator=
    ThreadTrace& operator=(const ThreadTrace&);

    //! Retrieve gslMemoryObject
    gslMemObject getCurrentGslMemObject(amd::Memory* );

    const Device&   gpuDevice_; //!< The backend device

    VirtualGPU&   gpu_;        //!< The virtual GPU device object

    CalThreadTraceReference*    calRef_;                   //!< Reference ThreadTrace
    gslShaderTraceBufferObject* threadTraceBufferObjs_;    //!< The buffer object for Thread Trace recording
    uint                        index_;                    //!< ThreadTrace index in the CAL container
    uint                        memBufferSizeTT_;          //!< ThreadTrace memory buffer size
    std::vector<amd::Memory*> memObj_;               //!< ThreadTrace memory object
    gslQueryObject  threadTrace_;                          //!< GSL thread trace query object
    uint                        amdThreadTraceMemObjsNum_; //!< ThreadTrace memory object`s number (should be equal to the SE number)
    bool                        isNewBufferBinded_;        //!< The indicator if new buffer was binded to the ThreadTrace object
    bool                        isBufferOnSubmit_;         //!< The indicator if "new buffer on submit" mode is used
};

} // namespace gpu

#endif // GPU_THREAD_TRACE_HPP_