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

/*******************************************************************************
 *
 *  Copyright (c) 2014 Advanced Micro Devices, Inc. (unpublished)
 *
 *  All rights reserved.  This notice is intended as a precaution against
 *  inadvertent publication and does not imply publication or any waiver
 *  of confidentiality.  The year included in the foregoing notice is the
 *  year of creation of the work.
 *
 ******************************************************************************/
#ifndef HWDBG_DEBUGMANAGER_H__
#define HWDBG_DEBUGMANAGER_H__

#include "gpuvirtual.hpp"
#include "gpudebugger.hpp"

namespace gpu {

class GpuDebugManager;
class Device;
class Memory;


/*!  \brief Debug Manager Class
 *
 *    The debug manager class is used to pass all the trap info to the
 *    kernel dispatch and then the kernel execution can use such trap information
 *    for kernel execution. This class contains the trap handler and shader event
 *    objects. The trap handler is setup by users and passed to the kernel dispatch.
 *    The shader event is to receive interrupts from the GPU and then users can
 *    perform various operations.
 *
 *    This class also provides the interface for setting up the pre-dispatch
 *    callback functions used by the profiler and debugger. It also provides
 *    a way to retrieve various debug information for the kernel execution.
 *
 */
class GpuDebugManager : public amd::HwDebugManager {
public:

    //!  Constructor of the debug manager class
    GpuDebugManager(amd::Device* device);

    //!  Destructor of the debug manager class
    ~GpuDebugManager();

    //!  Get the single instance of the GpuDebugManager class
    static GpuDebugManager* getDefaultInstance();

    //!  Destroy the GpuDebugManager class object
    static void destroyInstances();

    //!  Flush cache
    void flushCache(uint32_t mask);

    //!  Create the debug event
    DebugEvent createDebugEvent(const bool autoReset);

    //!  Wait for the debug event
    cl_int waitDebugEvent(DebugEvent pEvent, uint32_t timeOut) const;

    //!  Destroy the debug event
    void destroyDebugEvent(DebugEvent* pEvent);

    //!  Register the debugger
    cl_int registerDebugger(amd::Context*context, uintptr_t messageStorage);

    //!  Register the debugger with KMD after command queue has been created
    cl_int registerDebuggerOnQueue(device::VirtualDevice* vDevice);

    //!  Unregister the debugger
    void unregisterDebugger();

    //!  Send the wavefront control cmmand
    void wavefrontControl(uint32_t waveAction,
                            uint32_t waveMode,
                            uint32_t trapId,
                            void*  waveAddr) const;

    //!  Set address watching point
    void setAddressWatch(uint32_t numWatchPoints,
                           void** watchAddress,
                           uint64_t* watchMask,
                           uint64_t* watchMode,
                           DebugEvent* pEvent);

    //!  Get the packet information for dispatch
    void getPacketAmdInfo(const void* aqlCodeInfo, void* packetInfo) const;

    //!  Set global memory values
    void setGlobalMemory(amd::Memory* memObj, uint32_t offset, void* srcPtr, uint32_t size);

    //!  Execute the post-dispatch callback function
    void executePostDispatchCallBack();

    //!  Execute the pre-dispatch callback function
    void executePreDispatchCallBack(void*   aqlPacket,
                                    void*   toolInfo);

private:

    //!  Setup trap handler info for kernel execution
    void setupTrapInformation(DebugToolInfo* toolInfo);


protected:

    const VirtualGPU*    vGpu() const { return vGpu_; }

private:

    const gpu::Device*   device() const {
                                return reinterpret_cast<const gpu::Device *>(device_); }

    VirtualGPU*         vGpu_;             //!< the virtual GPU

    uintptr_t           debugMessages_;     //!< Pointer to a SHARED_DEBUG_MESSAGES pass to the KMD

    HwDbgAddressWatch*  addressWatch_;      //!< Address watch data
    size_t              addressWatchSize_;  //!< Size of address watch data

    //!  Arguments used by the callback function
    void*                                 oclEventHandle_;     //!< event handler
    const hsa_kernel_dispatch_packet_t*   aqlPacket_;          //!< AQL packet
};




}  // namespace gpu

#endif // HWDBG_DEBUGMANAGER_H__