qquick3drenderstats.cpp

Go to the documentation of this file.

// Copyright (C) 2019 The Qt Company Ltd.
// SPDX-License-Identifier: LicenseRef-Qt-Commercial OR GPL-3.0-only
 
#include "qquick3drenderstats_p.h"
#include <QtQuick3DRuntimeRender/private/qssgrendermesh_p.h>
#include <QtQuick/qquickwindow.h>
#include <QtQuick/qquickitem.h>
 
QT_BEGIN_NAMESPACE
 
QQuick3DRenderStats::QQuick3DRenderStats(QObject *parent)
    : QObject(parent)
{
    m_frameTimer.start();
}
 
int QQuick3DRenderStats::fps() const
{
    return m_fps;
}
 
float QQuick3DRenderStats::frameTime() const
{
    return m_results.frameTime;
}
 
float QQuick3DRenderStats::renderTime() const
{
    return m_results.renderTime;
}
 
float QQuick3DRenderStats::renderPrepareTime() const
{
    return m_results.renderPrepareTime;
}
 
float QQuick3DRenderStats::syncTime() const
{
    return m_results.syncTime;
}
 
float QQuick3DRenderStats::maxFrameTime() const
{
    return m_maxFrameTime;
}
 
float QQuick3DRenderStats::timestamp() const
{
    return m_frameTimer.nsecsElapsed() / 1000000.0f;
}
 
void QQuick3DRenderStats::startSync()
{
    m_syncStartTime = timestamp();
}
 
void QQuick3DRenderStats::endSync(bool dump)
{
    m_results.syncTime = timestamp() - m_syncStartTime;
 
    if (dump)
        qDebug("Sync took: %f ms", m_results.syncTime);
}
 
void QQuick3DRenderStats::startRender()
{
    m_renderStartTime = timestamp();
}
 
void QQuick3DRenderStats::startRenderPrepare()
{
    m_renderPrepareStartTime = timestamp();
}
 
void QQuick3DRenderStats::endRenderPrepare()
{
    m_results.renderPrepareTime = timestamp() - m_renderPrepareStartTime;
}
 
void QQuick3DRenderStats::endRender(bool dump)
{
    // Threading-wise this and onFrameSwapped are not perfect. These are called
    // on the render thread (if there is one) outside of the sync step, so
    // writing the data in m_results, which then may be read by the properties
    // on the main thread concurrently, is not ideal. But at least the data the
    // results are generated from (the m_* timings and all the stuff from
    // QSSGRhiContextStats) belong to the render thread, so that's good.
 
    m_renderingThisFrame = true;
    const float endTime = timestamp();
    m_results.renderTime = endTime - m_renderStartTime;
 
    if (dump)
        qDebug("Render took: %f ms (of which prep: %f ms)", m_results.renderTime, m_results.renderPrepareTime);
}
 
void QQuick3DRenderStats::onFrameSwapped()
{
    // NOTE: This is called on the render thread
    // This is the real start and end of a frame
 
    if (m_renderingThisFrame) {
        ++m_frameCount;
        m_results.frameTime = timestamp();
        m_internalMaxFrameTime = qMax(m_results.frameTime, m_internalMaxFrameTime);
 
        m_secTimer += m_results.frameTime;
        m_notifyTimer += m_results.frameTime;
 
        m_results.renderTime = m_results.frameTime - m_renderStartTime;
 
        processRhiContextStats();
 
        if (m_window) {
            QRhiSwapChain *sc = m_window->swapChain();
            if (sc) {
                QRhiCommandBuffer *cb = sc->currentFrameCommandBuffer();
                if (cb) {
                    const float msecs = float(cb->lastCompletedGpuTime() * 1000.0);
                    if (!qFuzzyIsNull(msecs))
                        m_results.lastCompletedGpuTime = msecs;
                }
            }
        }
 
        const float notifyInterval = 200.0f;
        if (m_notifyTimer >= notifyInterval) {
            m_notifyTimer -= notifyInterval;
 
            if (m_results.frameTime != m_notifiedResults.frameTime) {
                m_notifiedResults.frameTime = m_results.frameTime;
                emit frameTimeChanged();
            }
 
            if (m_results.syncTime != m_notifiedResults.syncTime) {
                m_notifiedResults.syncTime = m_results.syncTime;
                emit syncTimeChanged();
            }
 
            if (m_results.renderTime != m_notifiedResults.renderTime) {
                m_notifiedResults.renderTime = m_results.renderTime;
                m_notifiedResults.renderPrepareTime = m_results.renderPrepareTime;
                emit renderTimeChanged();
            }
 
            if (m_results.lastCompletedGpuTime != m_notifiedResults.lastCompletedGpuTime) {
                m_notifiedResults.lastCompletedGpuTime = m_results.lastCompletedGpuTime;
                emit lastCompletedGpuTimeChanged();
            }
 
            notifyRhiContextStats();
        }
 
        const float fpsInterval = 1000.0f;
        if (m_secTimer >= fpsInterval) {
            m_secTimer -= fpsInterval;
 
            m_fps = m_frameCount;
            m_frameCount = 0;
            emit fpsChanged();
 
            m_maxFrameTime = m_internalMaxFrameTime;
            m_internalMaxFrameTime = 0;
            emit maxFrameTimeChanged();
        }
 
        m_renderingThisFrame = false; // reset for next frame
    }
 
    // Always reset the frame timer
    m_frameTimer.restart();
}
 
void QQuick3DRenderStats::setRhiContext(QSSGRhiContext *ctx, QSSGRenderLayer *layer)
{
    // called from synchronize(), so on the render thread with gui blocked
 
    m_layer = layer;
    m_contextStats = &QSSGRhiContextStats::get(*ctx);
 
    // setExtendedDataCollectionEnabled will likely get called at some point
    // before this (so too early), sync the flag here as well now that we know
    // all we need to know.
    if (m_extendedDataCollectionEnabled)
        m_contextStats->dynamicDataSources.insert(layer);
 
    if (m_contextStats && m_contextStats->rhiCtx->rhi()) {
        const QString backendName = QString::fromUtf8(m_contextStats->rhiCtx->rhi()->backendName());
        if (m_graphicsApiName != backendName) {
            m_graphicsApiName = backendName;
            emit graphicsApiNameChanged();
        }
    }
}
 
void QQuick3DRenderStats::setWindow(QQuickWindow *window)
{
    if (m_window == window)
        return;
 
    if (m_window)
        disconnect(m_frameSwappedConnection);
 
    m_window = window;
 
    if (m_window) {
        m_frameSwappedConnection = connect(m_window, &QQuickWindow::afterFrameEnd,
                                           this, &QQuick3DRenderStats::onFrameSwapped,
                                           Qt::DirectConnection);
    }
}
 
bool QQuick3DRenderStats::extendedDataCollectionEnabled() const
{
    return m_extendedDataCollectionEnabled;
}
 
void QQuick3DRenderStats::setExtendedDataCollectionEnabled(bool enable)
{
    if (enable != m_extendedDataCollectionEnabled) {
        m_extendedDataCollectionEnabled = enable;
        emit extendedDataCollectionEnabledChanged();
    }
    if (m_contextStats) {
        // This is what allows recognizing that there is at least one DebugView
        // that is visible and wants all the data, and also helps in not
        // performing all the processing if the set is empty (because then we
        // know that no DebugView wants to display the data)
        if (m_extendedDataCollectionEnabled)
            m_contextStats->dynamicDataSources.insert(m_layer);
        else
            m_contextStats->dynamicDataSources.remove(m_layer);
    }
}
 
static const char *textureFormatStr(QRhiTexture::Format format)
{
    switch (format) {
    case QRhiTexture::RGBA8:
        return "RGBA8";
    case QRhiTexture::BGRA8:
        return "BGRA8";
    case QRhiTexture::R8:
        return "R8";
    case QRhiTexture::RG8:
        return "RG8";
    case QRhiTexture::R16:
        return "R16";
    case QRhiTexture::RG16:
        return "RG16";
    case QRhiTexture::RED_OR_ALPHA8:
        return "R8/A8";
    case QRhiTexture::RGBA16F:
        return "RGBA16F";
    case QRhiTexture::RGBA32F:
        return "RGBA32F";
    case QRhiTexture::R16F:
        return "R16F";
    case QRhiTexture::R32F:
        return "R32F";
    case QRhiTexture::RGB10A2:
        return "RGB10A2";
    case QRhiTexture::D16:
        return "D16";
    case QRhiTexture::D24:
        return "D24";
    case QRhiTexture::D24S8:
        return "D24S8";
    case QRhiTexture::D32F:
        return "D32F";
    case QRhiTexture::BC1:
        return "BC1";
    case QRhiTexture::BC2:
        return "BC2";
    case QRhiTexture::BC3:
        return "BC3";
    case QRhiTexture::BC4:
        return "BC4";
    case QRhiTexture::BC5:
        return "BC5";
    case QRhiTexture::BC6H:
        return "BC6H";
    case QRhiTexture::BC7:
        return "BC7";
    case QRhiTexture::ETC2_RGB8:
        return "ETC2_RGB8";
    case QRhiTexture::ETC2_RGB8A1:
        return "ETC2_RGB8A1";
    case QRhiTexture::ETC2_RGBA8:
        return "ETC2_RGBA8";
    case QRhiTexture::ASTC_4x4:
        return "ASTC_4x4";
    case QRhiTexture::ASTC_5x4:
        return "ASTC_5x4";
    case QRhiTexture::ASTC_5x5:
        return "ASTC_5x5";
    case QRhiTexture::ASTC_6x5:
        return "ASTC_6x5";
    case QRhiTexture::ASTC_6x6:
        return "ASTC_6x6";
    case QRhiTexture::ASTC_8x5:
        return "ASTC_8x5";
    case QRhiTexture::ASTC_8x6:
        return "ASTC_8x6";
    case QRhiTexture::ASTC_8x8:
        return "ASTC_8x8";
    case QRhiTexture::ASTC_10x5:
        return "ASTC_10x5";
    case QRhiTexture::ASTC_10x6:
        return "ASTC_10x6";
    case QRhiTexture::ASTC_10x8:
        return "ASTC_10x8";
    case QRhiTexture::ASTC_10x10:
        return "ASTC_10x10";
    case QRhiTexture::ASTC_12x10:
        return "ASTC_12x10";
    case QRhiTexture::ASTC_12x12:
        return "ASTC_12x12";
    default:
        break;
    }
    return "<unknown>";
}
 
static inline void printRenderPassDetails(QString *dst, const QSSGRhiContextStats::RenderPassInfo &rp)
{
    *dst += QString::asprintf("| %s | %dx%d | %llu | %llu |\n",
                              rp.rtName.constData(),
                              rp.pixelSize.width(),
                              rp.pixelSize.height(),
                              QSSGRhiContextStats::totalVertexCountForPass(rp),
                              QSSGRhiContextStats::totalDrawCallCountForPass(rp));
}
 
static inline QByteArray nameForRenderMesh(const QSSGRenderMesh *mesh)
{
    if (!mesh->subsets.isEmpty()) {
        auto buf = mesh->subsets[0].rhi.vertexBuffer;
        if (buf)
            return buf->buffer()->name();
    }
    return {};
}
 
void QQuick3DRenderStats::processRhiContextStats()
{
    if (!m_contextStats || !m_extendedDataCollectionEnabled)
        return;
 
    // the render pass list is per renderer, i.e. per View3D
    const QSSGRhiContextStats::PerLayerInfo data = m_contextStats->perLayerInfo[m_layer];
 
    const QSSGRhiContext *rhiCtx = m_contextStats->rhiCtx;
    const QSSGRhiContextPrivate *rhiCtxD = QSSGRhiContextPrivate::get(rhiCtx);
 
    // textures and meshes include all assets registered to the per-QQuickWindow QSSGRhiContext
    const QSSGRhiContextStats::GlobalInfo globalData = m_contextStats->globalInfo;
    const auto textures = rhiCtxD->m_textures;
    const auto meshes = rhiCtxD->m_meshes;
    const auto pipelines = rhiCtxD->m_pipelines;
 
    m_results.drawCallCount = 0;
    m_results.drawVertexCount = 0;
    for (const auto &pass : data.renderPasses) {
        m_results.drawCallCount += QSSGRhiContextStats::totalDrawCallCountForPass(pass);
        m_results.drawVertexCount += QSSGRhiContextStats::totalVertexCountForPass(pass);
    }
    m_results.drawCallCount += QSSGRhiContextStats::totalDrawCallCountForPass(data.externalRenderPass);
    m_results.drawVertexCount += QSSGRhiContextStats::totalVertexCountForPass(data.externalRenderPass);
 
    m_results.imageDataSize = globalData.imageDataSize;
    m_results.meshDataSize = globalData.meshDataSize;
 
    m_results.renderPassCount = data.renderPasses.size()
            + (data.externalRenderPass.pixelSize.isEmpty() ? 0 : 1);
 
    QString renderPassDetails = QLatin1String(R"(
| Name | Size | Vertices | Draw calls |
| ---- | ---- | -------- | ---------- |
)");
 
    if (!data.externalRenderPass.pixelSize.isEmpty())
        printRenderPassDetails(&renderPassDetails, data.externalRenderPass);
    for (const auto &pass : data.renderPasses) {
        if (!pass.pixelSize.isEmpty())
            printRenderPassDetails(&renderPassDetails, pass);
    }
    renderPassDetails += QString::asprintf("\nGenerated from QSSGRenderLayer %p", m_layer);
    m_results.renderPassDetails = renderPassDetails;
 
    if (m_results.activeTextures != textures) {
        m_results.activeTextures = textures;
        QString texDetails = QLatin1String(R"(
| Name | Size | Format | Mip | Flags |
| ---- | ---- | ------ | --- | ----- |
)");
        QList<QRhiTexture *> textureList = textures.values();
        std::sort(textureList.begin(), textureList.end(), [](QRhiTexture *a, QRhiTexture *b) {
            return a->name() < b->name();
        });
        for (QRhiTexture *tex : textureList) {
            int mipCount = 1;
            const QRhiTexture::Flags flags = tex->flags();
            if (flags.testFlag(QRhiTexture::MipMapped))
                mipCount = m_contextStats->rhiCtx->rhi()->mipLevelsForSize(tex->pixelSize());
            QByteArray flagMsg;
            if (flags.testFlag(QRhiTexture::CubeMap))
                flagMsg += QByteArrayLiteral("[cube]");
            texDetails += QString::asprintf("| %s | %dx%d | %s | %d | %s |\n",
                                            tex->name().constData(),
                                            tex->pixelSize().width(),
                                            tex->pixelSize().height(),
                                            textureFormatStr(tex->format()),
                                            mipCount,
                                            flagMsg.constData());
        }
        texDetails += QString::asprintf("\nAsset textures registered with QSSGRhiContext %p", m_contextStats->rhiCtx);
        m_results.textureDetails = texDetails;
    }
 
    if (m_results.activeMeshes != meshes) {
        m_results.activeMeshes = meshes;
        QString meshDetails = QLatin1String(R"(
| Name | Submeshes | Vertices | V.buf size | I.buf size |
| ---- | --------- | -------- | ---------- | ---------- |
)");
        QList<QSSGRenderMesh *> meshList = meshes.values();
        std::sort(meshList.begin(), meshList.end(), [](QSSGRenderMesh *a, QSSGRenderMesh *b) {
            return nameForRenderMesh(a) < nameForRenderMesh(b);
        });
        for (QSSGRenderMesh *mesh : meshList) {
            const QByteArray name = nameForRenderMesh(mesh);
            const int subsetCount = int(mesh->subsets.size());
            quint64 vertexCount = 0;
            quint32 vbufSize = 0;
            quint32 ibufSize = 0;
            if (subsetCount > 0) {
                for (const QSSGRenderSubset &subset : std::as_const(mesh->subsets))
                    vertexCount += subset.count;
                // submeshes ref into the same vertex and index buffer
                const QSSGRhiBuffer *vbuf = mesh->subsets[0].rhi.vertexBuffer.get();
                if (vbuf)
                    vbufSize = vbuf->buffer()->size();
                const QSSGRhiBuffer *ibuf = mesh->subsets[0].rhi.indexBuffer.get();
                if (ibuf)
                    ibufSize = ibuf->buffer()->size();
            }
            meshDetails += QString::asprintf("| %s | %d | %llu | %u | %u |\n",
                                             name.constData(),
                                             subsetCount,
                                             vertexCount,
                                             vbufSize,
                                             ibufSize);
 
        }
        meshDetails += QString::asprintf("\nAsset meshes registered with QSSGRhiContext %p", m_contextStats->rhiCtx);
        m_results.meshDetails = meshDetails;
    }
 
    m_results.pipelineCount = pipelines.count();
 
    m_results.materialGenerationTime = m_contextStats->globalInfo.materialGenerationTime;
    m_results.effectGenerationTime = m_contextStats->globalInfo.effectGenerationTime;
 
    m_results.rhiStats = m_contextStats->rhiCtx->rhi()->statistics();
}
 
void QQuick3DRenderStats::notifyRhiContextStats()
{
    if (!m_contextStats || !m_extendedDataCollectionEnabled)
        return;
 
    if (m_results.drawCallCount != m_notifiedResults.drawCallCount) {
        m_notifiedResults.drawCallCount = m_results.drawCallCount;
        emit drawCallCountChanged();
    }
 
    if (m_results.drawVertexCount != m_notifiedResults.drawVertexCount) {
        m_notifiedResults.drawVertexCount = m_results.drawVertexCount;
        emit drawVertexCountChanged();
    }
 
    if (m_results.imageDataSize != m_notifiedResults.imageDataSize) {
        m_notifiedResults.imageDataSize = m_results.imageDataSize;
        emit imageDataSizeChanged();
    }
 
    if (m_results.meshDataSize != m_notifiedResults.meshDataSize) {
        m_notifiedResults.meshDataSize = m_results.meshDataSize;
        emit meshDataSizeChanged();
    }
 
    if (m_results.renderPassCount != m_notifiedResults.renderPassCount) {
        m_notifiedResults.renderPassCount = m_results.renderPassCount;
        emit renderPassCountChanged();
    }
 
    if (m_results.renderPassDetails != m_notifiedResults.renderPassDetails) {
        m_notifiedResults.renderPassDetails = m_results.renderPassDetails;
        emit renderPassDetailsChanged();
    }
 
    if (m_results.textureDetails != m_notifiedResults.textureDetails) {
        m_notifiedResults.textureDetails = m_results.textureDetails;
        emit textureDetailsChanged();
    }
 
    if (m_results.meshDetails != m_notifiedResults.meshDetails) {
        m_notifiedResults.meshDetails = m_results.meshDetails;
        emit meshDetailsChanged();
    }
 
    if (m_results.pipelineCount != m_notifiedResults.pipelineCount) {
        m_notifiedResults.pipelineCount = m_results.pipelineCount;
        emit pipelineCountChanged();
    }
 
    if (m_results.materialGenerationTime != m_notifiedResults.materialGenerationTime) {
        m_notifiedResults.materialGenerationTime = m_results.materialGenerationTime;
        emit materialGenerationTimeChanged();
    }
 
    if (m_results.effectGenerationTime != m_notifiedResults.effectGenerationTime) {
        m_notifiedResults.effectGenerationTime = m_results.effectGenerationTime;
        emit effectGenerationTimeChanged();
    }
 
    if (m_results.rhiStats.totalPipelineCreationTime != m_notifiedResults.rhiStats.totalPipelineCreationTime) {
        m_notifiedResults.rhiStats.totalPipelineCreationTime = m_results.rhiStats.totalPipelineCreationTime;
        emit pipelineCreationTimeChanged();
    }
 
    if (m_results.rhiStats.allocCount != m_notifiedResults.rhiStats.allocCount) {
        m_notifiedResults.rhiStats.allocCount = m_results.rhiStats.allocCount;
        emit vmemAllocCountChanged();
    }
 
    if (m_results.rhiStats.usedBytes != m_notifiedResults.rhiStats.usedBytes) {
        m_notifiedResults.rhiStats.usedBytes = m_results.rhiStats.usedBytes;
        emit vmemUsedBytesChanged();
    }
}
 
quint64 QQuick3DRenderStats::drawCallCount() const
{
    return m_results.drawCallCount;
}
 
quint64 QQuick3DRenderStats::drawVertexCount() const
{
    return m_results.drawVertexCount;
}
 
quint64 QQuick3DRenderStats::imageDataSize() const
{
    return m_results.imageDataSize;
}
 
quint64 QQuick3DRenderStats::meshDataSize() const
{
    return m_results.meshDataSize;
}
 
int QQuick3DRenderStats::renderPassCount() const
{
    return m_results.renderPassCount;
}
 
QString QQuick3DRenderStats::renderPassDetails() const
{
    return m_results.renderPassDetails;
}
 
QString QQuick3DRenderStats::textureDetails() const
{
    return m_results.textureDetails;
}
 
QString QQuick3DRenderStats::meshDetails() const
{
    return m_results.meshDetails;
}
 
int QQuick3DRenderStats::pipelineCount() const
{
    return m_results.pipelineCount;
}
 
qint64 QQuick3DRenderStats::materialGenerationTime() const
{
    return m_results.materialGenerationTime;
}
 
qint64 QQuick3DRenderStats::effectGenerationTime() const
{
    return m_results.effectGenerationTime;
}
 
qint64 QQuick3DRenderStats::pipelineCreationTime() const
{
    return m_results.rhiStats.totalPipelineCreationTime;
}
 
quint32 QQuick3DRenderStats::vmemAllocCount() const
{
    return m_results.rhiStats.allocCount;
}
 
quint64 QQuick3DRenderStats::vmemUsedBytes() const
{
    return m_results.rhiStats.usedBytes;
}
 
QString QQuick3DRenderStats::graphicsApiName() const
{
    return m_graphicsApiName;
}
 
float QQuick3DRenderStats::lastCompletedGpuTime() const
{
    return m_results.lastCompletedGpuTime;
}
 
void QQuick3DRenderStats::releaseCachedResources()
{
    if (m_window)
        m_window->releaseResources();
    else
        qWarning("QQuick3DRenderStats: No window, cannot request releasing cached resources");
}
 
QT_END_NAMESPACE