rocm-systems/rocclr/runtime/platform/agent.hpp

//
// Copyright (c) 2010 Advanced Micro Devices, Inc. All rights reserved.
//

#ifndef AGENT_HPP_
#define AGENT_HPP_

#include "top.hpp"
#include "thread/monitor.hpp"

#include "amdocl/cl_agent_amd.h"

namespace amd {

class Agent : public _cl_agent
{
private:
    //! Linked list of agent instances
    static Agent* list_;
    //! Agent API entry points
    static cl_agent entryPoints_;
    //! Capabilities supported by this Agent implementation
    static cl_agent_capabilities potentialCapabilities_;
    //! Union of all agent's enabled capabilities
    static cl_agent_capabilities enabledCapabilities_;
    //! Monitor to protect the global capabilities
    static Monitor capabilitiesLock_;

public:
    //! Initialize the OpenCL agent
    static bool init();
    //! Teardown the agent.
    static void tearDown();
    //! Return the capabilities supported by this agent.
    static cl_agent_capabilities potentialCapabilities() {
        return potentialCapabilities_;
    }

#define AGENT_FLAG(name) \
    inline static bool shouldPost##name() { \
        return enabledCapabilities_.canGenerate##name != 0; \
    }

    AGENT_FLAG(ContextEvents);
    AGENT_FLAG(CommandQueueEvents);
    AGENT_FLAG(EventEvents);
    AGENT_FLAG(MemObjectEvents);
    AGENT_FLAG(SamplerEvents);
    AGENT_FLAG(ProgramEvents);
    AGENT_FLAG(KernelEvents);

#undef AGENT_FLAG

    //! Post a context creation event
    static void postContextCreate(cl_context context);
    //! Post a context destruction event
    static void postContextFree(cl_context context);

    //! Post a command queue creation event
    static void postCommandQueueCreate(cl_command_queue queue);
    //! Post a command queue destruction event
    static void postCommandQueueFree(cl_command_queue queue);

    //! Post an event creation event
    static void postEventCreate(cl_event event, cl_command_type type);
    //! Post an event destruction event
    static void postEventFree(cl_event event);
    //! Post and event status change event.
    static void postEventStatusChanged(
        cl_event event, cl_int execution_status, cl_long epoch_timestamp);

    //! Post a memory object creation event
    static void postMemObjectCreate(cl_mem memobj);
    //! Post a memory object destruction event
    static void postMemObjectFree(cl_mem memobj);
    //! Post a memory transfer (acquired by device) event
    static void postMemObjectAcquired(
        cl_mem memobj, cl_device_id device, cl_long elapsed_time);

    //! Post a sampler creation event
    static void postSamplerCreate(cl_sampler sampler);
    //! Post a sampler destruction event
    static void postSamplerFree(cl_sampler sampler);

    //! Post a program creation event
    static void postProgramCreate(cl_program program);
    //! Post a program destruction event
    static void postProgramFree(cl_program program);
    //! Post a program build event
    static void postProgramBuild(cl_program program);

    //! Post a kernel creation event
    static void postKernelCreate(cl_kernel kernel);
    //! Post a kernel destruction event
    static void postKernelFree(cl_kernel kernel);
    //! Post a kernel set argument event
    static void postKernelSetArg(
        cl_kernel kernel, cl_int arg_index, size_t size, const void* value_ptr);

private:
    Agent* next_;   //!< Next agent in the linked-list.
    void* library_; //!< Handle to the loaded module.
    bool ready_;    //!< Is this instance ready?

    //! Callbacks vector.
    cl_agent_callbacks callbacks_;
    //! Capabilities for this agent.
    cl_agent_capabilities capabilities_;

#define AGENT_FLAG(name) \
    inline bool canGenerate##name() { \
        return capabilities_.canGenerate##name != 0; \
    }

    AGENT_FLAG(ContextEvents);
    AGENT_FLAG(CommandQueueEvents);
    AGENT_FLAG(EventEvents);
    AGENT_FLAG(MemObjectEvents);
    AGENT_FLAG(SamplerEvents);
    AGENT_FLAG(ProgramEvents);
    AGENT_FLAG(KernelEvents);

#undef AGENT_FLAG

public:
    //! Construct a new agent.
    Agent(const char* moduleName);
    //! Destroy the agent
    ~Agent();

    //! Return true if this instance is ready for use.
    bool isReady() const { return ready_; }

    //! Set the callback vector for this agent
    cl_int setCallbacks(const cl_agent_callbacks *callbacks, size_t size);

    //! Return the current capabilities.
    cl_int getCapabilities(cl_agent_capabilities* caps);
    //! Set the current capabilities.
    cl_int setCapabilities(const cl_agent_capabilities* caps, bool install);

    //! Return the Agent instance from the given cl_agent
    inline static Agent* get(cl_agent* agent) {
        return const_cast<Agent*>(static_cast<const Agent*>(agent));
    }
};

} // namespace amd

#endif // AGENT_HPP_