qopengltimerquery.cpp

Go to the documentation of this file.

// Copyright (C) 2013 Klaralvdalens Datakonsult AB (KDAB).
// SPDX-License-Identifier: LicenseRef-Qt-Commercial OR LGPL-3.0-only OR GPL-2.0-only OR GPL-3.0-only
 
#include "qopengltimerquery.h"
 
#include "qopenglqueryhelper_p.h"
#include <QtCore/private/qobject_p.h>
#include <QtGui/QOpenGLContext>
#include <QtGui/QOpenGLFunctions>
 
QT_BEGIN_NAMESPACE
 
// Helper class used as fallback if OpenGL <3.3 is being used with EXT_timer_query
class QExtTimerQueryHelper
{
public:
    QExtTimerQueryHelper(QOpenGLContext *context)
    {
        Q_ASSERT(context);
        GetQueryObjectui64vEXT = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLuint , GLenum , GLuint64EXT *)>(context->getProcAddress("glGetQueryObjectui64vEXT"));
        GetQueryObjecti64vEXT = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLuint , GLenum , GLint64EXT *)>(context->getProcAddress("glGetQueryObjecti64vEXT"));
    }
 
    inline void glGetQueryObjectui64vEXT(GLuint id, GLenum pname, GLuint64EXT *params)
    {
        GetQueryObjectui64vEXT(id, pname, params);
    }
 
    inline void glGetQueryObjecti64vEXT(GLuint id, GLenum pname, GLint64EXT *params)
    {
        GetQueryObjecti64vEXT(id, pname, params);
    }
 
private:
    void (QOPENGLF_APIENTRYP GetQueryObjectui64vEXT)(GLuint id, GLenum pname, GLuint64EXT *params);
    void (QOPENGLF_APIENTRYP GetQueryObjecti64vEXT)(GLuint id, GLenum pname, GLint64EXT *params);
};
 
class QOpenGLTimerQueryPrivate : public QObjectPrivate
{
public:
    QOpenGLTimerQueryPrivate()
        : QObjectPrivate(),
          context(nullptr),
          ext(nullptr),
          timeInterval(0),
          timer(0)
    {
    }
 
    ~QOpenGLTimerQueryPrivate()
    {
        delete core;
        delete ext;
    }
 
    bool create();
    void destroy();
    void begin();
    void end();
    GLuint64 waitForTimeStamp() const;
    void recordTimestamp();
    bool isResultAvailable() const;
    GLuint64 result() const;
 
    // There are several cases we must handle:
    //   OpenGL >=3.3 includes timer queries as a core feature
    //   ARB_timer_query has same functionality as above. Requires OpenGL 3.2
    //   EXT_timer_query offers limited support. Can be used with OpenGL >=1.5
    //
    // Note that some implementations (OS X) provide OpenGL 3.2 but do not expose the
    // ARB_timer_query extension. In such situations we must also be able to handle
    // using the EXT_timer_query extension with any version of OpenGL.
    //
    // OpenGL 1.5 or above contains the generic query API and OpenGL 3.3 and
    // ARB_timer_query provide the 64-bit query API. These are wrapped by
    // QOpenGLQueryHelper. All we need to handle in addition is the EXT_timer_query
    // case and to take care not to call the Core/ARB functions when we only
    // have EXT_timer_query available.
    QOpenGLContext *context;
    QOpenGLQueryHelper *core;
    QExtTimerQueryHelper *ext;
    mutable GLuint64 timeInterval;
    GLuint timer;
};
 
bool QOpenGLTimerQueryPrivate::create()
{
    QOpenGLContext *ctx = QOpenGLContext::currentContext();
 
    if (timer && context == ctx)
        return true;
 
    context = ctx;
    if (!context) {
        qWarning("A current OpenGL context is required to create timer query objects");
        return false;
    }
 
    if (context->isOpenGLES()) {
        qWarning("QOpenGLTimerQuery: Not supported on OpenGL ES");
        return false;
    }
 
    // Resolve the functions provided by OpenGL 1.5 and OpenGL 3.3 or ARB_timer_query
    core = new QOpenGLQueryHelper(context);
 
    // Check to see if we also need to resolve the functions for EXT_timer_query
    QSurfaceFormat f = context->format();
    if (f.version() <= qMakePair(3, 2)
        && !context->hasExtension(QByteArrayLiteral("GL_ARB_timer_query"))
        && context->hasExtension(QByteArrayLiteral("GL_EXT_timer_query"))) {
        ext = new QExtTimerQueryHelper(context);
    } else if (f.version() <= qMakePair(3, 2)
               && !context->hasExtension(QByteArrayLiteral("GL_ARB_timer_query"))
               && !context->hasExtension(QByteArrayLiteral("GL_EXT_timer_query"))) {
        qWarning("QOpenGLTimerQuery requires one of:\n"
                 "  OpenGL 3.3 or newer,\n"
                 "  OpenGL 3.2 and the ARB_timer_query extension\n"
                 "  or the EXT_timer query extension");
        return false;
    }
 
    core->glGenQueries(1, &timer);
    return (timer != 0);
}
 
void QOpenGLTimerQueryPrivate::destroy()
{
    if (!timer)
        return;
 
    core->glDeleteQueries(1, &timer);
    timer = 0;
    context = nullptr;
}
 
// GL_TIME_ELAPSED_EXT is not defined on OS X 10.6
#if !defined(GL_TIME_ELAPSED_EXT)
#define GL_TIME_ELAPSED_EXT 0x88BF
#endif
 
// GL_TIME_ELAPSED is not defined on OS X 10.7 or 10.8 yet
#if !defined(GL_TIME_ELAPSED)
#define GL_TIME_ELAPSED GL_TIME_ELAPSED_EXT
#endif
 
void QOpenGLTimerQueryPrivate::begin()
{
    core->glBeginQuery(GL_TIME_ELAPSED, timer);
}
 
void QOpenGLTimerQueryPrivate::end()
{
    core->glEndQuery(GL_TIME_ELAPSED);
}
 
void QOpenGLTimerQueryPrivate::recordTimestamp()
{
    // Don't call glQueryCounter if we only have EXT_timer_query
#if defined(GL_TIMESTAMP)
    if (!ext)
        core->glQueryCounter(timer, GL_TIMESTAMP);
    else
        qWarning("QOpenGLTimerQuery::recordTimestamp() requires OpenGL 3.3 or GL_ARB_timer_query");
#else
    qWarning("QOpenGLTimerQuery::recordTimestamp() requires OpenGL 3.3 or GL_ARB_timer_query");
#endif
}
 
GLuint64 QOpenGLTimerQueryPrivate::waitForTimeStamp() const
{
    GLint64 tmp = 0;
#if defined(GL_TIMESTAMP)
    if (!ext)
        core->glGetInteger64v(GL_TIMESTAMP, &tmp);
    else
        qWarning("QOpenGLTimerQuery::waitForTimestamp() requires OpenGL 3.3 or GL_ARB_timer_query");
#else
    qWarning("QOpenGLTimerQuery::waitForTimestamp() requires OpenGL 3.3 or GL_ARB_timer_query");
#endif
    GLuint64 timestamp(tmp);
    return timestamp;
}
 
bool QOpenGLTimerQueryPrivate::isResultAvailable() const
{
    GLuint available = GL_FALSE;
    core->glGetQueryObjectuiv(timer, GL_QUERY_RESULT_AVAILABLE, &available);
    return available;
}
 
GLuint64 QOpenGLTimerQueryPrivate::result() const
{
    if (!ext)
        core->glGetQueryObjectui64v(timer, GL_QUERY_RESULT, &timeInterval);
    else
        ext->glGetQueryObjectui64vEXT(timer, GL_QUERY_RESULT, &timeInterval);
    return timeInterval;
}
 
QOpenGLTimerQuery::QOpenGLTimerQuery(QObject *parent)
    : QObject(*new QOpenGLTimerQueryPrivate, parent)
{
}
 
QOpenGLTimerQuery::~QOpenGLTimerQuery()
{
    QOpenGLContext* ctx = QOpenGLContext::currentContext();
 
    Q_D(QOpenGLTimerQuery);
    QOpenGLContext *oldContext = nullptr;
    if (d->context != ctx) {
        oldContext = ctx;
        if (d->context->makeCurrent(oldContext->surface())) {
            ctx = d->context;
        } else {
            qWarning("QOpenGLTimerQuery::~QOpenGLTimerQuery() failed to make query objects's context current");
            ctx = nullptr;
        }
    }
 
    if (ctx)
        destroy();
 
    if (oldContext) {
        if (!oldContext->makeCurrent(oldContext->surface()))
            qWarning("QOpenGLTimerQuery::~QOpenGLTimerQuery() failed to restore current context");
    }
}
 
bool QOpenGLTimerQuery::create()
{
    Q_D(QOpenGLTimerQuery);
    return d->create();
}
 
void QOpenGLTimerQuery::destroy()
{
    Q_D(QOpenGLTimerQuery);
    d->destroy();
}
 
bool QOpenGLTimerQuery::isCreated() const
{
    Q_D(const QOpenGLTimerQuery);
    return (d->timer != 0);
}
 
GLuint QOpenGLTimerQuery::objectId() const
{
    Q_D(const QOpenGLTimerQuery);
    return d->timer;
}
 
void QOpenGLTimerQuery::begin()
{
    Q_D(QOpenGLTimerQuery);
    d->begin();
}
 
void QOpenGLTimerQuery::end()
{
    Q_D(QOpenGLTimerQuery);
    d->end();
}
 
void QOpenGLTimerQuery::recordTimestamp()
{
    Q_D(QOpenGLTimerQuery);
    return d->recordTimestamp();
}
 
GLuint64 QOpenGLTimerQuery::waitForTimestamp() const
{
    Q_D(const QOpenGLTimerQuery);
    return d->waitForTimeStamp();
}
 
bool QOpenGLTimerQuery::isResultAvailable() const
{
    Q_D(const QOpenGLTimerQuery);
    return d->isResultAvailable();
}
 
GLuint64 QOpenGLTimerQuery::waitForResult() const
{
    Q_D(const QOpenGLTimerQuery);
    return d->result();
}
 
 
class QOpenGLTimeMonitorPrivate : public QObjectPrivate
{
public:
    QOpenGLTimeMonitorPrivate()
        : QObjectPrivate(),
          timers(),
          timeSamples(),
          context(nullptr),
          core(nullptr),
          ext(nullptr),
          requestedSampleCount(2),
          currentSample(-1),
          timerQueryActive(false)
    {
    }
 
    ~QOpenGLTimeMonitorPrivate()
    {
        delete core;
        delete ext;
    }
 
    bool create();
    void destroy();
    void recordSample();
    bool isResultAvailable() const;
    QList<GLuint64> samples() const;
    QList<GLuint64> intervals() const;
    void reset();
 
    QList<GLuint> timers;
    mutable QList<GLuint64> timeSamples;
 
    QOpenGLContext *context;
    QOpenGLQueryHelper *core;
    QExtTimerQueryHelper *ext;
 
    int requestedSampleCount;
    int currentSample;
    mutable bool timerQueryActive;
};
 
bool QOpenGLTimeMonitorPrivate::create()
{
    if (!timers.isEmpty() && timers.at(0) != 0 && timers.size() == requestedSampleCount)
        return true;
 
    QOpenGLContext *ctx = QOpenGLContext::currentContext();
    if (context && context != ctx) {
        qWarning("QTimeMonitor: Attempting to use different OpenGL context to recreate timers.\n"
                 "Please call destroy() first or use the same context to previously create");
        return false;
    }
 
    context = ctx;
    if (!context) {
        qWarning("A current OpenGL context is required to create timer query objects");
        return false;
    }
 
    // Resize the vectors that hold the timers and the recorded samples
    timers.resize(requestedSampleCount);
    timeSamples.resize(requestedSampleCount);
 
    // Resolve the functions provided by OpenGL 1.5 and OpenGL 3.3 or ARB_timer_query
    core = new QOpenGLQueryHelper(context);
 
    // Check to see if we also need to resolve the functions for EXT_timer_query
    QSurfaceFormat f = context->format();
    if (f.version() <= qMakePair(3, 2)
        && !context->hasExtension(QByteArrayLiteral("GL_ARB_timer_query"))
        && context->hasExtension(QByteArrayLiteral("GL_EXT_timer_query"))) {
        ext = new QExtTimerQueryHelper(context);
    } else if (f.version() <= qMakePair(3, 2)
               && !context->hasExtension(QByteArrayLiteral("GL_ARB_timer_query"))
               && !context->hasExtension(QByteArrayLiteral("GL_EXT_timer_query"))) {
        qWarning("QOpenGLTimeMonitor requires one of:\n"
                 "  OpenGL 3.3 or newer,\n"
                 "  OpenGL 3.2 and the ARB_timer_query extension\n"
                 "  or the EXT_timer query extension");
        return false;
    }
 
    core->glGenQueries(requestedSampleCount, timers.data());
    return (timers.at(0) != 0);
}
 
void QOpenGLTimeMonitorPrivate::destroy()
{
    if (timers.isEmpty() || timers.at(0) == 0)
        return;
 
    core->glDeleteQueries(timers.size(), timers.data());
    timers.clear();
    delete core;
    core = nullptr;
    delete ext;
    ext = nullptr;
    context = nullptr;
}
 
void QOpenGLTimeMonitorPrivate::recordSample()
{
    // Use glQueryCounter() and GL_TIMESTAMP where available.
    // Otherwise, simulate it with glBeginQuery()/glEndQuery()
    if (!ext) {
#if defined(GL_TIMESTAMP)
        core->glQueryCounter(timers.at(++currentSample), GL_TIMESTAMP);
#endif
    } else {
        if (currentSample == -1) {
            core->glBeginQuery(GL_TIME_ELAPSED_EXT, timers.at(++currentSample));
            timerQueryActive = true;
        } else if (currentSample < timers.size() - 1) {
            core->glEndQuery(GL_TIME_ELAPSED_EXT);
            core->glBeginQuery(GL_TIME_ELAPSED_EXT, timers.at(++currentSample));
        } else {
            if (timerQueryActive) {
                core->glEndQuery(GL_TIME_ELAPSED_EXT);
                timerQueryActive = false;
            }
        }
    }
}
 
bool QOpenGLTimeMonitorPrivate::isResultAvailable() const
{
    // The OpenGL spec says that if a query result is ready then the results of all queries
    // of the same type issued before it must also be ready. Therefore we only need to check
    // the availability of the result for the last issued query
    GLuint available = GL_FALSE;
    core->glGetQueryObjectuiv(timers.at(currentSample), GL_QUERY_RESULT_AVAILABLE, &available);
    return available;
}
 
QList<GLuint64> QOpenGLTimeMonitorPrivate::samples() const
{
    // For the Core and ARB options just ask for the timestamp for each timer query.
    // For the EXT implementation we cannot obtain timestamps so we defer any result
    // collection to the intervals() function
    if (!ext) {
        for (int i = 0; i <= currentSample; ++i)
            core->glGetQueryObjectui64v(timers.at(i), GL_QUERY_RESULT, &timeSamples[i]);
    } else {
        qWarning("QOpenGLTimeMonitor::samples() requires OpenGL >=3.3\n"
                 "or OpenGL 3.2 and GL_ARB_timer_query");
    }
    return timeSamples;
}
 
QList<GLuint64> QOpenGLTimeMonitorPrivate::intervals() const
{
    QList<GLuint64> intervals(timers.size() - 1);
    if (!ext) {
        // Obtain the timestamp samples and calculate the interval durations
        const QList<GLuint64> timeStamps = samples();
        for (int i = 0; i < intervals.size(); ++i)
            intervals[i] = timeStamps[i+1] - timeStamps[i];
    } else {
        // Stop the last timer if needed
        if (timerQueryActive) {
            core->glEndQuery(GL_TIME_ELAPSED_EXT);
            timerQueryActive = false;
        }
 
        // Obtain the results from all timers apart from the redundant last one. In this
        // case the results actually are the intervals not timestamps
        for (int i = 0; i < currentSample; ++i)
            ext->glGetQueryObjectui64vEXT(timers.at(i), GL_QUERY_RESULT, &intervals[i]);
    }
 
    return intervals;
}
 
void QOpenGLTimeMonitorPrivate::reset()
{
    currentSample = -1;
    timeSamples.fill(0);
}
 
 
QOpenGLTimeMonitor::QOpenGLTimeMonitor(QObject *parent)
    : QObject(*new QOpenGLTimeMonitorPrivate, parent)
{
}
 
QOpenGLTimeMonitor::~QOpenGLTimeMonitor()
{
    QOpenGLContext* ctx = QOpenGLContext::currentContext();
 
    Q_D(QOpenGLTimeMonitor);
    QOpenGLContext *oldContext = nullptr;
    if (d->context != ctx) {
        oldContext = ctx;
        if (d->context->makeCurrent(oldContext->surface())) {
            ctx = d->context;
        } else {
            qWarning("QOpenGLTimeMonitor::~QOpenGLTimeMonitor() failed to make time monitor's context current");
            ctx = nullptr;
        }
    }
 
    if (ctx)
        destroy();
 
    if (oldContext) {
        if (!oldContext->makeCurrent(oldContext->surface()))
            qWarning("QOpenGLTimeMonitor::~QOpenGLTimeMonitor() failed to restore current context");
    }
}
 
void QOpenGLTimeMonitor::setSampleCount(int sampleCount)
{
    // We need at least 2 samples to get an interval
    if (sampleCount < 2)
        return;
    Q_D(QOpenGLTimeMonitor);
    d->requestedSampleCount = sampleCount;
}
 
int QOpenGLTimeMonitor::sampleCount() const
{
    Q_D(const QOpenGLTimeMonitor);
    return d->requestedSampleCount;
}
 
bool QOpenGLTimeMonitor::create()
{
    Q_D(QOpenGLTimeMonitor);
    return d->create();
}
 
void QOpenGLTimeMonitor::destroy()
{
    Q_D(QOpenGLTimeMonitor);
    d->destroy();
}
 
bool QOpenGLTimeMonitor::isCreated() const
{
    Q_D(const QOpenGLTimeMonitor);
    return (!d->timers.isEmpty() && d->timers.at(0) != 0);
}
 
QList<GLuint> QOpenGLTimeMonitor::objectIds() const
{
    Q_D(const QOpenGLTimeMonitor);
    return d->timers;
}
 
int QOpenGLTimeMonitor::recordSample()
{
    Q_D(QOpenGLTimeMonitor);
    d->recordSample();
    return d->currentSample;
}
 
bool QOpenGLTimeMonitor::isResultAvailable() const
{
    Q_D(const QOpenGLTimeMonitor);
    return d->isResultAvailable();
}
 
QList<GLuint64> QOpenGLTimeMonitor::waitForSamples() const
{
    Q_D(const QOpenGLTimeMonitor);
    return d->samples();
}
 
QList<GLuint64> QOpenGLTimeMonitor::waitForIntervals() const
{
    Q_D(const QOpenGLTimeMonitor);
    return d->intervals();
}
 
void QOpenGLTimeMonitor::reset()
{
    Q_D(QOpenGLTimeMonitor);
    d->reset();
}
 
QT_END_NAMESPACE
 
#include "moc_qopengltimerquery.cpp"