AMD_performance_monitor.hpp

Go to the documentation of this file.

#pragma once
#ifndef OGLPLUS_EXT_AMD_PERFORMANCE_MONITOR_1203031902_HPP
#define OGLPLUS_EXT_AMD_PERFORMANCE_MONITOR_1203031902_HPP

#include <oglplus/extension.hpp>
#include <oglplus/enumerations.hpp>
#include <oglplus/object/wrapper.hpp>

#include <cassert>
#include <vector>

namespace oglplus {

#if OGLPLUS_DOCUMENTATION_ONLY || GL_AMD_performance_monitor


OGLPLUS_ENUM_CLASS_BEGIN(PerfMonitorAMDType, GLenum)
#include <oglplus/enums/ext/amd_perf_monitor_type.ipp>
OGLPLUS_ENUM_CLASS_END(PerfMonitorAMDType)

#if !OGLPLUS_NO_ENUM_VALUE_NAMES
#include <oglplus/enums/ext/amd_perf_monitor_type_names.ipp>
#endif

#if !OGLPLUS_ENUM_VALUE_RANGES
#include <oglplus/enums/ext/amd_perf_monitor_type_range.ipp>
#endif

class PerfMonitorAMDGroup;
class AMD_performance_monitor;


class PerfMonitorAMDCounter
{
private:
    GLuint _group;
    GLuint _counter;

    friend class PerfMonitorAMDGroup;
    friend class ObjectOps<tag::DirectState, tag::PerfMonitorAMD>;

    PerfMonitorAMDCounter(GLuint group, GLuint counter)
     : _group(group)
     , _counter(counter)
    { }
public:

    String GetString(void) const
    {
        GLsizei length = 0;
        OGLPLUS_GLFUNC(GetPerfMonitorCounterStringAMD)(
            _group,
            _counter,
            0,
            &length,
            nullptr
        );
        OGLPLUS_CHECK(
            GetPerfMonitorCounterStringAMD,
            Error,
            Index(_group)
        );

        std::vector<GLchar> buffer(length);
        OGLPLUS_GLFUNC(GetPerfMonitorCounterStringAMD)(
            _group,
            _counter,
            GLsizei(buffer.size()),
            &length,
            buffer.data()
        );
        OGLPLUS_CHECK(
            GetPerfMonitorCounterStringAMD,
            Error,
            Index(_group)
        );
        return String(buffer.data(), buffer.size());
    }


    PerfMonitorAMDType Type(void) const
    {
        GLenum result;
        OGLPLUS_GLFUNC(GetPerfMonitorCounterInfoAMD)(
            _group,
            _counter,
            GL_COUNTER_TYPE_AMD,
            &result
        );
        OGLPLUS_CHECK(
            GetPerfMonitorCounterInfoAMD,
            Error,
            Index(_group)
        );
        return PerfMonitorAMDType(result);
    }
};


class PerfMonitorAMDGroup
{
private:
    GLuint _group;

    friend class AMD_performance_monitor;

    PerfMonitorAMDGroup(GLuint group)
     : _group(group)
    { }
public:

    String GetString(void) const
    {
        GLsizei length = 0;
        OGLPLUS_GLFUNC(GetPerfMonitorGroupStringAMD)(
            _group,
            0,
            &length,
            nullptr
        );
        OGLPLUS_CHECK(
            GetPerfMonitorGroupStringAMD,
            Error,
            Index(_group)
        );

        std::vector<GLchar> buffer(length);
        OGLPLUS_GLFUNC(GetPerfMonitorGroupStringAMD)(
            _group,
            GLsizei(buffer.size()),
            &length,
            buffer.data()
        );
        OGLPLUS_CHECK(
            GetPerfMonitorGroupStringAMD,
            Error,
            Index(_group)
        );
        return String(buffer.data(), buffer.size());
    }


    void GetCounters(
        GLint& max_active_counters,
        std::vector<PerfMonitorAMDCounter>& counters
    ) const
    {
        GLint count = 0;
        OGLPLUS_GLFUNC(GetPerfMonitorCountersAMD)(
            _group,
            &count,
            &max_active_counters,
            0,
            nullptr
        );
        OGLPLUS_CHECK(
            GetPerfMonitorCountersAMD,
            Error,
            Index(_group)
        );

        std::vector<GLuint> buffer(count);
        OGLPLUS_GLFUNC(GetPerfMonitorCountersAMD)(
            _group,
            &count,
            &max_active_counters,
            buffer.size(),
            buffer.data()
        );
        OGLPLUS_CHECK(
            GetPerfMonitorCountersAMD,
            Error,
            Index(_group)
        );

        counters.clear();
        counters.reserve(count);
        for(auto i=buffer.begin(), e=buffer.end(); i!=e; ++i)
            counters.push_back(PerfMonitorAMDCounter(_group, *i));
    }


    std::vector<PerfMonitorAMDCounter>
    GetCounters(GLint& max_active_counters) const
    {
        std::vector<PerfMonitorAMDCounter> result;
        GetCounters(max_active_counters, result);
        return result;
    }

};


class PerfMonitorAMDResult
{
private:
    PerfMonitorAMDCounter _counter;

    union {
        GLfloat _fl;
        struct {
            GLuint _lo;
            GLuint _hi;
        } _qw;
    };

    PerfMonitorAMDResult(
        PerfMonitorAMDCounter counter,
        GLuint lo,
        GLuint hi
    ): _counter(counter)
    {
        _qw._lo = lo;
        _qw._hi = hi;
    }

    friend class ObjectOps<tag::DirectState, tag::PerfMonitorAMD>;
public:
    PerfMonitorAMDCounter Counter(void) const
    {
        return _counter;
    }

    GLuint Low(void) const
    {
        return _qw._lo;
    }

    GLuint High(void) const
    {
        return _qw._lo;
    }

    GLfloat Float(void) const
    {
        return _fl;
    }
};


template <>
class ObjGenDelOps<tag::PerfMonitorAMD>
{
protected:
    static void Gen(tag::Generate, GLsizei count, GLuint* names)
    {
        assert(names != nullptr);
        OGLPLUS_GLFUNC(GenPerfMonitorsAMD)(count, names);
        OGLPLUS_CHECK_SIMPLE(GenSamplers);
    }

    static void Delete(GLsizei count, GLuint* names)
    {
        assert(names != nullptr);
        OGLPLUS_GLFUNC(DeletePerfMonitorsAMD)(count, names);
        OGLPLUS_VERIFY_SIMPLE(DeleteSamplers);
    }

    static GLboolean IsA(GLuint name)
    {
        assert(name != 0);
        return GL_TRUE;
    }
};


template <>
class ObjectOps<tag::DirectState, tag::PerfMonitorAMD>
 : public ObjZeroOps<tag::DirectState, tag::PerfMonitorAMD>
{
protected:
    ObjectOps(void){ }
public:

    void SelectCounters(
        bool enable,
        const std::vector<PerfMonitorAMDCounter>& counters
    ) const
    {
        if(counters.empty()) return;

        std::vector<GLuint> list(counters.size());
        GLuint group = counters[0]._group;

        for(size_t i=0, n=counters.size(); i!=n; ++i)
        {
            assert(group == counters[i]._group);
            list[i] = counters[i]._counter;
        }

        OGLPLUS_GLFUNC(SelectPerfMonitorCountersAMD)(
            this->_name,
            enable? GL_TRUE: GL_FALSE,
            group,
            GLint(list.size()),
            list.data()
        );
        OGLPLUS_CHECK(
            SelectPerfMonitorCountersAMD,
            ObjectError,
            Object(*this)
        );
    }


    void Begin(void) const
    {
        OGLPLUS_GLFUNC(BeginPerfMonitorAMD)(this->_name);
        OGLPLUS_CHECK(
            BeginPerfMonitorAMD,
            ObjectError,
            Object(*this)
        );
    }


    void End(void) const
    {
        OGLPLUS_GLFUNC(EndPerfMonitorAMD)(this->_name);
        OGLPLUS_CHECK(
            EndPerfMonitorAMD,
            ObjectError,
            Object(*this)
        );
    }


    bool ResultAvailable(void) const
    {
        GLuint result = 0;
        OGLPLUS_GLFUNC(GetPerfMonitorCounterDataAMD)(
            this->_name,
            GL_PERFMON_RESULT_AVAILABLE_AMD,
            sizeof(result),
            &result,
            nullptr
        );
        OGLPLUS_CHECK(
            GetPerfMonitorCounterDataAMD,
            ObjectError,
            Object(*this)
        );
        return result != 0;
    }


    void Result(std::vector<PerfMonitorAMDResult>& results) const
    {
        GLuint size = 0;
        OGLPLUS_GLFUNC(GetPerfMonitorCounterDataAMD)(
            this->_name,
            GL_PERFMON_RESULT_SIZE_AMD,
            sizeof(size),
            &size,
            nullptr
        );
        OGLPLUS_CHECK(
            GetPerfMonitorCounterDataAMD,
            ObjectError,
            Object(*this)
        );

        std::vector<GLuint> data(size / sizeof(GLuint));
        OGLPLUS_GLFUNC(GetPerfMonitorCounterDataAMD)(
            this->_name,
            GL_PERFMON_RESULT_AMD,
            data.size() * sizeof(GLuint),
            data.data(),
            nullptr
        );
        OGLPLUS_CHECK(
            GetPerfMonitorCounterDataAMD,
            ObjectError,
            Object(*this)
        );

        results.clear();
        results.reserve(data.size() / 3);

        auto i = data.begin(), e = data.end();
        while(i != e)
        {
            GLuint group = *i++;
            assert(i != e);
            GLuint ctr = *i++;
            assert(i != e);

            PerfMonitorAMDCounter counter(group, ctr);
            auto type = counter.Type();
            GLuint lo = *i++, hi = 0;
            if(type == PerfMonitorAMDType::UnsignedInt64)
                hi = *i++;

            results.push_back(PerfMonitorAMDResult(counter, lo, hi));
        }
    }
};

typedef ObjectOps<tag::DirectState, tag::PerfMonitorAMD>
    PerfMonitorAMDOps;


typedef Object<PerfMonitorAMDOps> PerfMonitorAMD;


class AMD_performance_monitor
{
public:
    OGLPLUS_EXTENSION_CLASS(AMD, performance_monitor)

    

    void GetGroups(std::vector<PerfMonitorAMDGroup>& groups) const
    {
        GLint count = 0;
        OGLPLUS_GLFUNC(GetPerfMonitorGroupsAMD)(
            &count,
            0,
            nullptr
        );
        OGLPLUS_CHECK_SIMPLE(GetPerfMonitorGroupsAMD);

        std::vector<GLuint> buffer(count);
        OGLPLUS_GLFUNC(GetPerfMonitorGroupsAMD)(
            &count,
            buffer.size(),
            buffer.data()
        );
        OGLPLUS_CHECK_SIMPLE(GetPerfMonitorGroupsAMD);

        groups.clear();
        groups.reserve(count);
        for(auto i=buffer.begin(), e=buffer.end(); i!=e; ++i)
            groups.push_back(PerfMonitorAMDGroup(*i));
    }


    std::vector<PerfMonitorAMDGroup> GetGroups(void) const
    {
        std::vector<PerfMonitorAMDGroup> result;
        GetGroups(result);
        return result;
    }
};
#endif

} // namespace oglplus

#endif // include guard