Profiler2GPU.cpp

Go to the documentation of this file.

/* Copyright (c) 2011 Wildfire Games
 *
 * Permission is hereby granted, free of charge, to any person obtaining
 * a copy of this software and associated documentation files (the
 * "Software"), to deal in the Software without restriction, including
 * without limitation the rights to use, copy, modify, merge, publish,
 * distribute, sublicense, and/or sell copies of the Software, and to
 * permit persons to whom the Software is furnished to do so, subject to
 * the following conditions:
 * 
 * The above copyright notice and this permission notice shall be included
 * in all copies or substantial portions of the Software.
 * 
 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
 * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
 * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
 * IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
 * CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
 * TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
 * SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
 */

#include "precompiled.h"

#include "Profiler2GPU.h"

#include "lib/ogl.h"
#include "lib/allocators/shared_ptr.h"
#include "ps/ConfigDB.h"
#include "ps/Profiler2.h"

#if !CONFIG2_GLES

class CProfiler2GPU_base
{
    NONCOPYABLE(CProfiler2GPU_base);

protected:
    CProfiler2GPU_base(CProfiler2& profiler, const char* name) :
        m_Profiler(profiler), m_Storage(profiler, name)
    {
        m_Storage.RecordSyncMarker(m_Profiler.GetTime());
        m_Storage.Record(CProfiler2::ITEM_EVENT, m_Profiler.GetTime(), "thread start");

        m_Profiler.AddThreadStorage(&m_Storage);
    }

    ~CProfiler2GPU_base()
    {
        m_Profiler.RemoveThreadStorage(&m_Storage);
    }

    CProfiler2& m_Profiler;
    CProfiler2::ThreadStorage m_Storage;
};

//////////////////////////////////////////////////////////////////////////

// Base class for ARB_timer_query, EXT_timer_query
class CProfiler2GPU_timer_query : public CProfiler2GPU_base
{
protected:
    CProfiler2GPU_timer_query(CProfiler2& profiler, const char* name) :
        CProfiler2GPU_base(profiler, name)
    {
    }

    ~CProfiler2GPU_timer_query()
    {
        if (!m_FreeQueries.empty())
            pglDeleteQueriesARB(m_FreeQueries.size(), &m_FreeQueries[0]);
        ogl_WarnIfError();
    }

    // Returns a new GL query object (or a recycled old one)
    GLuint NewQuery()
    {
        if (m_FreeQueries.empty())
        {
            // Generate a batch of new queries
            m_FreeQueries.resize(8);
            pglGenQueriesARB(m_FreeQueries.size(), &m_FreeQueries[0]);
            ogl_WarnIfError();
        }

        GLuint query = m_FreeQueries.back();
        m_FreeQueries.pop_back();
        return query;
    }

    std::vector<GLuint> m_FreeQueries; // query objects that are allocated but not currently in used
};

//////////////////////////////////////////////////////////////////////////

/*
 * GL_ARB_timer_query supports sync and async queries for absolute GPU
 * timestamps, which lets us time regions of code relative to the CPU.
 * At the start of a frame, we record the CPU time and sync GPU timestamp,
 * giving the time-vs-timestamp offset.
 * At each enter/leave-region event, we do an async GPU timestamp query.
 * When all the queries for a frame have their results available,
 * we convert their GPU timestamps into CPU times and record the data.
 */
class CProfiler2GPU_ARB_timer_query : public CProfiler2GPU_timer_query
{
    struct SEvent
    {
        const char* id;
        GLuint query;
        bool isEnter; // true if entering region; false if leaving
    };

    struct SFrame
    {
        u32 num;

        double syncTimeStart; // CPU time at start of maybe this frame or a recent one
        GLint64 syncTimestampStart; // GL timestamp corresponding to timeStart

        std::vector<SEvent> events;
    };

    std::deque<SFrame> m_Frames;

public:
    static bool IsSupported()
    {
        return ogl_HaveExtension("GL_ARB_timer_query");
    }

    CProfiler2GPU_ARB_timer_query(CProfiler2& profiler) :
        CProfiler2GPU_timer_query(profiler, "gpu_arb")
    {
        // TODO: maybe we should check QUERY_COUNTER_BITS to ensure it's
        // high enough (but apparently it might trigger GL errors on ATI)
    }

    ~CProfiler2GPU_ARB_timer_query()
    {
        // Pop frames to return queries to the free list
        while (!m_Frames.empty())
            PopFrontFrame();
    }

    void FrameStart()
    {
        ProcessFrames();

        SFrame frame;
        frame.num = m_Profiler.GetFrameNumber();

        // On (at least) some NVIDIA Windows drivers, when GPU-bound, or when
        // vsync enabled and not CPU-bound, the first glGet* call at the start
        // of a frame appears to trigger a wait (to stop the GPU getting too
        // far behind, or to wait for the vsync period).
        // That will be this GL_TIMESTAMP get, which potentially distorts the
        // reported results. So we'll only do it fairly rarely, and for most
        // frames we'll just assume the clocks don't drift much
        
        const double RESYNC_PERIOD = 1.0; // seconds

        double now = m_Profiler.GetTime();

        if (m_Frames.empty() || now > m_Frames.back().syncTimeStart + RESYNC_PERIOD)
        {
            PROFILE2("profile timestamp resync");

            pglGetInteger64v(GL_TIMESTAMP, &frame.syncTimestampStart);
            ogl_WarnIfError();

            frame.syncTimeStart = m_Profiler.GetTime();
            // (Have to do GetTime again after GL_TIMESTAMP, because GL_TIMESTAMP
            // might wait a while before returning its now-current timestamp)
        }
        else
        {
            // Reuse the previous frame's sync data
            frame.syncTimeStart = m_Frames[m_Frames.size()-1].syncTimeStart;
            frame.syncTimestampStart = m_Frames[m_Frames.size()-1].syncTimestampStart;
        }

        m_Frames.push_back(frame);

        RegionEnter("frame");
    }

    void FrameEnd()
    {
        RegionLeave("frame");
    }

    void RecordRegion(const char* id, bool isEnter)
    {
        ENSURE(!m_Frames.empty());
        SFrame& frame = m_Frames.back();

        SEvent event;
        event.id = id;
        event.query = NewQuery();
        event.isEnter = isEnter;

        pglQueryCounter(event.query, GL_TIMESTAMP);
        ogl_WarnIfError();

        frame.events.push_back(event);
    }

    void RegionEnter(const char* id)
    {
        RecordRegion(id, true);
    }

    void RegionLeave(const char* id)
    {
        RecordRegion(id, false);
    }

private:

    void ProcessFrames()
    {
        while (!m_Frames.empty())
        {
            SFrame& frame = m_Frames.front();

            // Queries become available in order so we only need to check the last one
            GLint available = 0;
            pglGetQueryObjectivARB(frame.events.back().query, GL_QUERY_RESULT_AVAILABLE, &available);
            ogl_WarnIfError();
            if (!available)
                break;

            // The frame's queries are now available, so retrieve and record all their results:

            for (size_t i = 0; i < frame.events.size(); ++i)
            {
                GLuint64 queryTimestamp = 0;
                pglGetQueryObjectui64v(frame.events[i].query, GL_QUERY_RESULT, &queryTimestamp);
                    // (use the non-suffixed function here, as defined by GL_ARB_timer_query)
                ogl_WarnIfError();

                // Convert to absolute CPU-clock time
                double t = frame.syncTimeStart + (double)(queryTimestamp - frame.syncTimestampStart) / 1e9;

                // Record a frame-start for syncing
                if (i == 0)
                    m_Storage.RecordFrameStart(t);

                if (frame.events[i].isEnter)
                    m_Storage.Record(CProfiler2::ITEM_ENTER, t, frame.events[i].id);
                else
                    m_Storage.Record(CProfiler2::ITEM_LEAVE, t, frame.events[i].id);

                // Associate the frame number with the "frame" region
                if (i == 0)
                    m_Storage.RecordAttributePrintf("%u", frame.num);
            }

            PopFrontFrame();
        }
    }

    void PopFrontFrame()
    {
        ENSURE(!m_Frames.empty());
        SFrame& frame = m_Frames.front();
        for (size_t i = 0; i < frame.events.size(); ++i)
            m_FreeQueries.push_back(frame.events[i].query);
        m_Frames.pop_front();
    }
};

//////////////////////////////////////////////////////////////////////////

/*
 * GL_EXT_timer_query only supports async queries for elapsed time,
 * and only a single simultaneous query.
 * We can't correctly convert it to absolute time, so we just pretend
 * each GPU frame starts the same time as the CPU for that frame.
 * We do a query for elapsed time between every adjacent enter/leave-region event.
 * When all the queries for a frame have their results available,
 * we sum the elapsed times to calculate when each event occurs within the
 * frame, and record the data.
 */
class CProfiler2GPU_EXT_timer_query : public CProfiler2GPU_timer_query
{
    struct SEvent
    {
        const char* id;
        GLuint query; // query for time elapsed from this event until the next, or 0 for final event
        bool isEnter; // true if entering region; false if leaving
    };

    struct SFrame
    {
        u32 num;
        double timeStart; // CPU time at frame start
        std::vector<SEvent> events;
    };

    std::deque<SFrame> m_Frames;

public:
    static bool IsSupported()
    {
        return ogl_HaveExtension("GL_EXT_timer_query");
    }

    CProfiler2GPU_EXT_timer_query(CProfiler2& profiler) :
        CProfiler2GPU_timer_query(profiler, "gpu_ext")
    {
    }

    ~CProfiler2GPU_EXT_timer_query()
    {
        // Pop frames to return queries to the free list
        while (!m_Frames.empty())
            PopFrontFrame();
    }

    void FrameStart()
    {
        ProcessFrames();

        SFrame frame;
        frame.num = m_Profiler.GetFrameNumber();
        frame.timeStart = m_Profiler.GetTime();

        m_Frames.push_back(frame);

        RegionEnter("frame");
    }

    void FrameEnd()
    {
        RegionLeave("frame");

        pglEndQueryARB(GL_TIME_ELAPSED);
        ogl_WarnIfError();
    }

    void RecordRegion(const char* id, bool isEnter)
    {
        ENSURE(!m_Frames.empty());
        SFrame& frame = m_Frames.back();

        // Must call glEndQuery before calling glGenQueries (via NewQuery),
        // for compatibility with the GL_EXT_timer_query spec (which says
        // GL_INVALID_OPERATION if a query of any target is active; the ARB
        // spec and OpenGL specs don't appear to say that, but the AMD drivers
        // implement that error (see Trac #1033))

        if (!frame.events.empty())
        {
            pglEndQueryARB(GL_TIME_ELAPSED);
            ogl_WarnIfError();
        }

        SEvent event;
        event.id = id;
        event.query = NewQuery();
        event.isEnter = isEnter;

        pglBeginQueryARB(GL_TIME_ELAPSED, event.query);
        ogl_WarnIfError();

        frame.events.push_back(event);
    }

    void RegionEnter(const char* id)
    {
        RecordRegion(id, true);
    }

    void RegionLeave(const char* id)
    {
        RecordRegion(id, false);
    }

private:
    void ProcessFrames()
    {
        while (!m_Frames.empty())
        {
            SFrame& frame = m_Frames.front();

            // Queries become available in order so we only need to check the last one
            GLint available = 0;
            pglGetQueryObjectivARB(frame.events.back().query, GL_QUERY_RESULT_AVAILABLE, &available);
            ogl_WarnIfError();
            if (!available)
                break;

            // The frame's queries are now available, so retrieve and record all their results:

            double t = frame.timeStart;
            m_Storage.RecordFrameStart(t);

            for (size_t i = 0; i < frame.events.size(); ++i)
            {
                if (frame.events[i].isEnter)
                    m_Storage.Record(CProfiler2::ITEM_ENTER, t, frame.events[i].id);
                else
                    m_Storage.Record(CProfiler2::ITEM_LEAVE, t, frame.events[i].id);

                // Associate the frame number with the "frame" region
                if (i == 0)
                    m_Storage.RecordAttributePrintf("%u", frame.num);

                // Advance by the elapsed time to the next event
                GLuint64 queryElapsed = 0;
                pglGetQueryObjectui64vEXT(frame.events[i].query, GL_QUERY_RESULT, &queryElapsed);
                    // (use the EXT-suffixed function here, as defined by GL_EXT_timer_query)
                ogl_WarnIfError();
                t += (double)queryElapsed / 1e9;
            }

            PopFrontFrame();
        }
    }

    void PopFrontFrame()
    {
        ENSURE(!m_Frames.empty());
        SFrame& frame = m_Frames.front();
        for (size_t i = 0; i < frame.events.size(); ++i)
            m_FreeQueries.push_back(frame.events[i].query);
        m_Frames.pop_front();
    }
};

//////////////////////////////////////////////////////////////////////////

/*
 * GL_INTEL_performance_queries is not officially documented
 * (see http://zaynar.co.uk/docs/gl-intel-performance-queries.html)
 * but it's potentially useful so we'll support it anyway.
 * It supports async queries giving elapsed time plus a load of other
 * counters that we'd like to use, and supports many simultaneous queries
 * (unlike GL_EXT_timer_query).
 * There are multiple query types (typically 2), each with its own set of
 * multiple counters.
 * On each enter-region event, we start a new set of queries.
 * On each leave-region event, we end the corresponding set of queries.
 * We can't tell the offsets between the enter events of nested regions,
 * so we pretend they all got entered at the same time.
 */
class CProfiler2GPU_INTEL_performance_queries : public CProfiler2GPU_base
{
    struct SEvent
    {
        const char* id;
        bool isEnter;
        std::vector<GLuint> queries; // if isEnter, one per SPerfQueryType; else empty
    };

    struct SFrame
    {
        u32 num;
        double timeStart; // CPU time at frame start
        std::vector<SEvent> events;
        std::vector<size_t> activeRegions; // stack of indexes into events
    };

    std::deque<SFrame> m_Frames;

    // Counters listed by the graphics driver for a particular query type
    struct SPerfCounter
    {
        std::string name;
        std::string desc;
        GLuint offset;
        GLuint size;
        GLuint type;
    };

    // Query types listed by the graphics driver
    struct SPerfQueryType
    {
        GLuint queryTypeId;
        std::string name;
        GLuint counterBufferSize;
        std::vector<SPerfCounter> counters;

        std::vector<GLuint> freeQueries; // query objects that are allocated but not currently in use
    };

    std::vector<SPerfQueryType> m_QueryTypes;

    #define INTEL_PERFQUERIES_NONBLOCK             0x83FA
    #define INTEL_PERFQUERIES_BLOCK                0x83FB
    #define INTEL_PERFQUERIES_TYPE_UNSIGNED_INT    0x9402
    #define INTEL_PERFQUERIES_TYPE_UNSIGNED_INT64  0x9403
    #define INTEL_PERFQUERIES_TYPE_FLOAT           0x9404
    #define INTEL_PERFQUERIES_TYPE_BOOL            0x9406

public:
    static bool IsSupported()
    {
        return ogl_HaveExtension("GL_INTEL_performance_queries");
    }

    CProfiler2GPU_INTEL_performance_queries(CProfiler2& profiler) :
         CProfiler2GPU_base(profiler, "gpu_intel")
    {
        LoadPerfCounters();
    }

    ~CProfiler2GPU_INTEL_performance_queries()
    {
        // Pop frames to return queries to the free list
        while (!m_Frames.empty())
            PopFrontFrame();

        for (size_t i = 0; i < m_QueryTypes.size(); ++i)
            for (size_t j = 0; j < m_QueryTypes[i].freeQueries.size(); ++j)
                pglDeletePerfQueryINTEL(m_QueryTypes[i].freeQueries[j]);

        ogl_WarnIfError();
    }

    void FrameStart()
    {
        ProcessFrames();

        SFrame frame;
        frame.num = m_Profiler.GetFrameNumber();
        frame.timeStart = m_Profiler.GetTime();

        m_Frames.push_back(frame);

        RegionEnter("frame");
    }

    void FrameEnd()
    {
        RegionLeave("frame");
    }

    void RegionEnter(const char* id)
    {
        ENSURE(!m_Frames.empty());
        SFrame& frame = m_Frames.back();

        SEvent event;
        event.id = id;
        event.isEnter = true;

        for (size_t i = 0; i < m_QueryTypes.size(); ++i)
        {
            GLuint id = NewQuery(i);
            pglBeginPerfQueryINTEL(id);
            ogl_WarnIfError();
            event.queries.push_back(id);
        }

        frame.activeRegions.push_back(frame.events.size());

        frame.events.push_back(event);
    }

    void RegionLeave(const char* id)
    {
        ENSURE(!m_Frames.empty());
        SFrame& frame = m_Frames.back();

        ENSURE(!frame.activeRegions.empty());
        SEvent& activeEvent = frame.events[frame.activeRegions.back()];

        for (size_t i = 0; i < m_QueryTypes.size(); ++i)
        {
            pglEndPerfQueryINTEL(activeEvent.queries[i]);
            ogl_WarnIfError();
        }

        frame.activeRegions.pop_back();

        SEvent event;
        event.id = id;
        event.isEnter = false;
        frame.events.push_back(event);
    }

private:
    GLuint NewQuery(size_t queryIdx)
    {
        ENSURE(queryIdx < m_QueryTypes.size());

        if (m_QueryTypes[queryIdx].freeQueries.empty())
        {
            GLuint id;
            pglCreatePerfQueryINTEL(m_QueryTypes[queryIdx].queryTypeId, &id);
            ogl_WarnIfError();
            return id;
        }

        GLuint id = m_QueryTypes[queryIdx].freeQueries.back();
        m_QueryTypes[queryIdx].freeQueries.pop_back();
        return id;
    }

    void ProcessFrames()
    {
        while (!m_Frames.empty())
        {
            SFrame& frame = m_Frames.front();

            // Queries don't become available in order, so check them all before
            // trying to read the results from any
            for (size_t j = 0; j < m_QueryTypes.size(); ++j)
            {
                size_t size = m_QueryTypes[j].counterBufferSize;
                shared_ptr<char> buf(new char[size], ArrayDeleter());

                for (size_t i = 0; i < frame.events.size(); ++i)
                {
                    if (!frame.events[i].isEnter)
                        continue;

                    GLuint length = 0;
                    pglGetPerfQueryDataINTEL(frame.events[i].queries[j], INTEL_PERFQUERIES_NONBLOCK, size, buf.get(), &length);
                    ogl_WarnIfError();
                    if (length == 0)
                        return;
                }
            }

            double lastTime = frame.timeStart;
            std::stack<double> endTimes;

            m_Storage.RecordFrameStart(frame.timeStart);

            for (size_t i = 0; i < frame.events.size(); ++i)
            {
                if (frame.events[i].isEnter)
                {
                    m_Storage.Record(CProfiler2::ITEM_ENTER, lastTime, frame.events[i].id);

                    if (i == 0)
                        m_Storage.RecordAttributePrintf("%u", frame.num);

                    double elapsed = 0.0;

                    for (size_t j = 0; j < m_QueryTypes.size(); ++j)
                    {
                        GLuint length;
                        char* buf = new char[m_QueryTypes[j].counterBufferSize];
                        pglGetPerfQueryDataINTEL(frame.events[i].queries[j], INTEL_PERFQUERIES_BLOCK, m_QueryTypes[j].counterBufferSize, buf, &length);
                        ogl_WarnIfError();
                        ENSURE(length == m_QueryTypes[j].counterBufferSize);

                        m_Storage.RecordAttributePrintf("-- %s --", m_QueryTypes[j].name.c_str());

                        for (size_t k = 0; k < m_QueryTypes[j].counters.size(); ++k)
                        {
                            SPerfCounter& counter = m_QueryTypes[j].counters[k];

                            if (counter.type == INTEL_PERFQUERIES_TYPE_UNSIGNED_INT)
                            {
                                ENSURE(counter.size == 4);
                                GLuint value = 0;
                                memcpy(&value, buf + counter.offset, counter.size);
                                m_Storage.RecordAttributePrintf("%s: %u", counter.name.c_str(), value);
                            }
                            else if (counter.type == INTEL_PERFQUERIES_TYPE_UNSIGNED_INT64)
                            {
                                ENSURE(counter.size == 8);
                                GLuint64 value = 0;
                                memcpy(&value, buf + counter.offset, counter.size);
                                m_Storage.RecordAttributePrintf("%s: %.0f", counter.name.c_str(), (double)value);

                                if (counter.name == "TotalTime")
                                    elapsed = (double)value / 1e6;
                            }
                            else if (counter.type == INTEL_PERFQUERIES_TYPE_FLOAT)
                            {
                                ENSURE(counter.size == 4);
                                GLfloat value = 0;
                                memcpy(&value, buf + counter.offset, counter.size);
                                m_Storage.RecordAttributePrintf("%s: %f", counter.name.c_str(), value);
                            }
                            else if (counter.type == INTEL_PERFQUERIES_TYPE_BOOL)
                            {
                                ENSURE(counter.size == 4);
                                GLuint value = 0;
                                memcpy(&value, buf + counter.offset, counter.size);
                                ENSURE(value == 0 || value == 1);
                                m_Storage.RecordAttributePrintf("%s: %u", counter.name.c_str(), value);
                            }
                            else
                            {
                                debug_warn(L"unrecognised Intel performance counter type");
                            }
                        }

                        delete[] buf;
                    }

                    endTimes.push(lastTime + elapsed);
                }
                else
                {
                    lastTime = endTimes.top();
                    endTimes.pop();
                    m_Storage.Record(CProfiler2::ITEM_LEAVE, lastTime, frame.events[i].id);
                }
            }

            PopFrontFrame();
        }
    }

    void PopFrontFrame()
    {
        ENSURE(!m_Frames.empty());
        SFrame& frame = m_Frames.front();
        for (size_t i = 0; i < frame.events.size(); ++i)
            if (frame.events[i].isEnter)
                for (size_t j = 0; j < m_QueryTypes.size(); ++j)
                    m_QueryTypes[j].freeQueries.push_back(frame.events[i].queries[j]);
        m_Frames.pop_front();
    }

    void LoadPerfCounters()
    {
        GLuint queryTypeId;
        pglGetFirstPerfQueryIdINTEL(&queryTypeId);
        ogl_WarnIfError();
        do
        {
            char queryName[256];
            GLuint counterBufferSize, numCounters, maxQueries, unknown;
            pglGetPerfQueryInfoINTEL(queryTypeId, ARRAY_SIZE(queryName), queryName, &counterBufferSize, &numCounters, &maxQueries, &unknown);
            ogl_WarnIfError();
            ENSURE(unknown == 1);

            SPerfQueryType query;
            query.queryTypeId = queryTypeId;
            query.name = queryName;
            query.counterBufferSize = counterBufferSize;

            for (GLuint counterId = 1; counterId <= numCounters; ++counterId)
            {
                char counterName[256];
                char counterDesc[2048];
                GLuint counterOffset, counterSize, counterUsage, counterType;
                GLuint64 unknown2;
                pglGetPerfCounterInfoINTEL(queryTypeId, counterId, ARRAY_SIZE(counterName), counterName, ARRAY_SIZE(counterDesc), counterDesc, &counterOffset, &counterSize, &counterUsage, &counterType, &unknown2);
                ogl_WarnIfError();
                ENSURE(unknown2 == 0 || unknown2 == 1);

                SPerfCounter counter;
                counter.name = counterName;
                counter.desc = counterDesc;
                counter.offset = counterOffset;
                counter.size = counterSize;
                counter.type = counterType;
                query.counters.push_back(counter);
            }

            m_QueryTypes.push_back(query);

            pglGetNextPerfQueryIdINTEL(queryTypeId, &queryTypeId);
            ogl_WarnIfError();

        } while (queryTypeId);
    }
};

//////////////////////////////////////////////////////////////////////////

CProfiler2GPU::CProfiler2GPU(CProfiler2& profiler) :
    m_Profiler(profiler), m_ProfilerARB(NULL), m_ProfilerEXT(NULL), m_ProfilerINTEL(NULL)
{
    bool enabledARB = false;
    bool enabledEXT = false;
    bool enabledINTEL = false;
    CFG_GET_VAL("profiler2.gpu.arb.enable", Bool, enabledARB);
    CFG_GET_VAL("profiler2.gpu.ext.enable", Bool, enabledEXT);
    CFG_GET_VAL("profiler2.gpu.intel.enable", Bool, enabledINTEL);

    // Only enable either ARB or EXT, not both, because they are redundant
    // (EXT is only needed for compatibility with older systems), and because
    // using both triggers GL_INVALID_OPERATION on AMD drivers (see comment
    // in CProfiler2GPU_EXT_timer_query::RecordRegion)
    if (enabledARB && CProfiler2GPU_ARB_timer_query::IsSupported())
    {
        m_ProfilerARB = new CProfiler2GPU_ARB_timer_query(m_Profiler);
    }
    else if (enabledEXT && CProfiler2GPU_EXT_timer_query::IsSupported())
    {
        m_ProfilerEXT = new CProfiler2GPU_EXT_timer_query(m_Profiler);
    }

    // The INTEL mode should be compatible with ARB/EXT (though no current
    // drivers support both), and provides complementary data, so enable it
    // when possible
    if (enabledINTEL && CProfiler2GPU_INTEL_performance_queries::IsSupported())
    {
        m_ProfilerINTEL = new CProfiler2GPU_INTEL_performance_queries(m_Profiler);
    }
}

CProfiler2GPU::~CProfiler2GPU()
{
    SAFE_DELETE(m_ProfilerARB);
    SAFE_DELETE(m_ProfilerEXT);
    SAFE_DELETE(m_ProfilerINTEL);
}

void CProfiler2GPU::FrameStart()
{
    if (m_ProfilerARB)
        m_ProfilerARB->FrameStart();

    if (m_ProfilerEXT)
        m_ProfilerEXT->FrameStart();

    if (m_ProfilerINTEL)
        m_ProfilerINTEL->FrameStart();
}

void CProfiler2GPU::FrameEnd()
{
    if (m_ProfilerARB)
        m_ProfilerARB->FrameEnd();

    if (m_ProfilerEXT)
        m_ProfilerEXT->FrameEnd();

    if (m_ProfilerINTEL)
        m_ProfilerINTEL->FrameEnd();
}

void CProfiler2GPU::RegionEnter(const char* id)
{
    if (m_ProfilerARB)
        m_ProfilerARB->RegionEnter(id);

    if (m_ProfilerEXT)
        m_ProfilerEXT->RegionEnter(id);

    if (m_ProfilerINTEL)
        m_ProfilerINTEL->RegionEnter(id);
}

void CProfiler2GPU::RegionLeave(const char* id)
{
    if (m_ProfilerARB)
        m_ProfilerARB->RegionLeave(id);

    if (m_ProfilerEXT)
        m_ProfilerEXT->RegionLeave(id);

    if (m_ProfilerINTEL)
        m_ProfilerINTEL->RegionLeave(id);
}

#else // CONFIG2_GLES

CProfiler2GPU::CProfiler2GPU(CProfiler2& profiler) :
    m_Profiler(profiler), m_ProfilerARB(NULL), m_ProfilerEXT(NULL), m_ProfilerINTEL(NULL)
{
}

CProfiler2GPU::~CProfiler2GPU() { }

void CProfiler2GPU::FrameStart() { }
void CProfiler2GPU::FrameEnd() { }
void CProfiler2GPU::RegionEnter(const char* UNUSED(id)) { }
void CProfiler2GPU::RegionLeave(const char* UNUSED(id)) { }

#endif