src/profiler/rive_profile.cpp

#include "rive/profiler/rive_profile.hpp"
#include "rive/core/vector_binary_writer.hpp"
#include "rive/artboard.hpp"
#include "rive/artboard_host.hpp"
#include "rive/artboard_component_list.hpp"
#include "rive/nested_artboard.hpp"
#include <algorithm>

#ifdef RIVE_MICROPROFILE
#include "rive/profiler/microprofile_emscripten.h"
#include "microprofile.h"

namespace
{
void writeInt64(rive::VectorBinaryWriter& writer, int64_t value)
{
    writer.write(reinterpret_cast<const uint8_t*>(&value), sizeof(value));
}

void writeProfileHeader(rive::VectorBinaryWriter& writer)
{
    MicroProfile* pState = MicroProfileGet();
    writer.write((uint32_t)0x52505246); // "RPRF" magic
    writer.write((uint32_t)2);          // version 2
    writeInt64(writer, MicroProfileTicksPerSecondCpu());
    writer.writeVarUint(pState->nTotalTimers);
    for (uint32_t i = 0; i < pState->nTotalTimers; i++)
    {
        const auto& info = pState->TimerInfo[i];
        writer.write(std::string(info.pName));
        writer.write((uint32_t)info.nGroupIndex);
        writer.write((uint32_t)info.nColor);
    }
    writer.writeVarUint(pState->nGroupCount);
    for (uint32_t i = 0; i < pState->nGroupCount; i++)
    {
        writer.write(std::string(pState->GroupInfo[i].pName));
    }
}

void writeFrameEvents(rive::VectorBinaryWriter& writer,
                      MicroProfile* pState,
                      uint32_t frameIndex,
                      uint32_t nextFrameIndex)
{
    const MicroProfileFrameState& frame = pState->Frames[frameIndex];
    const MicroProfileFrameState& nextFrame = pState->Frames[nextFrameIndex];

    std::vector<uint8_t> payload;
    rive::VectorBinaryWriter pw(&payload);
    writeInt64(pw, frame.nFrameStartCpu);
    writeInt64(pw, nextFrame.nFrameStartCpu);
    uint32_t totalEvents = 0;
    for (uint32_t threadIdx = 0; threadIdx < MICROPROFILE_MAX_THREADS;
         threadIdx++)
    {
        MicroProfileThreadLog* pLog = pState->Pool[threadIdx];
        if (!pLog)
            continue;
        uint32_t logStart = frame.nLogStart[threadIdx];
        uint32_t logEnd = nextFrame.nLogStart[threadIdx];
        if (logEnd >= logStart)
            totalEvents += (logEnd - logStart);
        else
            totalEvents += (MICROPROFILE_BUFFER_SIZE - logStart) + logEnd;
    }
    pw.writeVarUint(totalEvents);
    for (uint32_t threadIdx = 0; threadIdx < MICROPROFILE_MAX_THREADS;
         threadIdx++)
    {
        MicroProfileThreadLog* pLog = pState->Pool[threadIdx];
        if (!pLog)
            continue;
        uint32_t logStart = frame.nLogStart[threadIdx];
        uint32_t logEnd = nextFrame.nLogStart[threadIdx];
        for (uint32_t k = logStart; k != logEnd;
             k = (k + 1) % MICROPROFILE_BUFFER_SIZE)
        {
            MicroProfileLogEntry entry = pLog->Log[k];
            uint64_t nType = MicroProfileLogType(entry);
            uint64_t nTimerIndex = MicroProfileLogTimerIndex(entry);
            int64_t nTick =
                MicroProfileLogTickDifference(frame.nFrameStartCpu, entry);
            uint8_t eventType = (nType == MP_LOG_ENTER)   ? 0
                                : (nType == MP_LOG_LEAVE) ? 1
                                                          : 2;
            pw.write(eventType);
            pw.writeVarUint((uint32_t)nTimerIndex);
            writeInt64(pw, nTick);
        }
    }

    writer.write((uint8_t)0x01);
    writer.writeVarUint(static_cast<uint32_t>(payload.size()));
    writer.write(payload.data(), payload.size());
}
} // namespace
#endif

namespace rive
{

RiveProfile& RiveProfile::instance()
{
    static RiveProfile s_instance;
    return s_instance;
}

void RiveProfile::init()
{
#ifdef RIVE_MICROPROFILE
    MicroProfileSetEnableAllGroups(true);
    MicroProfileSetForceEnable(true);
    MicroProfileOnThreadCreate("MainThread");
    MicroProfileInit();
#endif
}

void RiveProfile::frame()
{
#ifdef RIVE_MICROPROFILE
    // Frame is typically a no-op at start of loop; MicroProfile tracks
    // internally
#endif
}

void RiveProfile::endFrame()
{
#ifdef RIVE_MICROPROFILE
    if (m_profilingActive)
    {
        MicroProfileFlip();
    }
#endif
}

void RiveProfile::start()
{
#ifdef RIVE_MICROPROFILE
    m_profilingActive = true;
    m_headerWritten = false;
    m_lastFlushedFrameIndex = 0;
    m_stringTable.clear();
    m_stringList.clear();
    MicroProfileSetEnableAllGroups(true);
    MicroProfileSetForceEnable(true);
    MicroProfile* pState = MicroProfileGet();
    if (pState != nullptr)
    {
        // Skip the boundary frame. nFramePutIndex only advances on flip, and we
        // only flip while profiling is active, so the frame slot at
        // nFramePutIndex holds a stale tick from before this session (the
        // MicroProfileInit tick, or the last flip of a previous session). Its
        // "duration" would be the idle gap before start() rather than a real
        // frame, producing an absurd spike. Start one frame later so the first
        // emitted frame is bounded by two in-session flips.
        m_lastFlushedFrameIndex = pState->nFramePutIndex + 1;
    }
#endif
}

void RiveProfile::stop()
{
#ifdef RIVE_MICROPROFILE
    m_profilingActive = false;
    MicroProfileSetForceEnable(false);
#endif
}

bool RiveProfile::isActive() const
{
#ifdef RIVE_MICROPROFILE
    return m_profilingActive;
#else
    return false;
#endif
}

void RiveProfile::flushFrameDataTo(std::vector<uint8_t>& buffer)
{
#ifdef RIVE_MICROPROFILE
    MicroProfile* pState = MicroProfileGet();
    if (pState == nullptr)
        return;
    VectorBinaryWriter writer(&buffer);
    if (!m_headerWritten)
    {
        writeProfileHeader(writer);
        m_headerWritten = true;
    }
    uint64_t currentFrameIndex = pState->nFramePutIndex;
    const uint32_t GPU_DELAY = MICROPROFILE_GPU_FRAME_DELAY + 1;
    if (currentFrameIndex <= m_lastFlushedFrameIndex + GPU_DELAY)
        return;
    uint64_t endFrameIndex = currentFrameIndex - GPU_DELAY;
    uint64_t maxHistory = MICROPROFILE_MAX_FRAME_HISTORY - GPU_DELAY - 2;
    if (endFrameIndex - m_lastFlushedFrameIndex > maxHistory)
    {
        m_lastFlushedFrameIndex = endFrameIndex - maxHistory;
    }
    // Emit every real frame, however slow. The whole point of the profiler is
    // to measure performance across devices, so a genuinely slow frame (even
    // hundreds of ms on weak hardware) MUST reach the tool - we do not drop by
    // magnitude here. The only frames skipped are corrupt ones: a negative
    // duration means the two frame-start slots are out of order (e.g. a stale
    // ring slot that hasn't been written this session). Pauses/stalls (which
    // look like a single very long frame) are left in the stream and flagged
    // downstream so they can be shown without wrecking the aggregates.
    for (uint64_t frameIdx = m_lastFlushedFrameIndex; frameIdx < endFrameIndex;
         frameIdx++)
    {
        uint32_t ringIdx =
            static_cast<uint32_t>(frameIdx % MICROPROFILE_MAX_FRAME_HISTORY);
        uint32_t nextRingIdx = static_cast<uint32_t>(
            (frameIdx + 1) % MICROPROFILE_MAX_FRAME_HISTORY);
        int64_t durationTicks = pState->Frames[nextRingIdx].nFrameStartCpu -
                                pState->Frames[ringIdx].nFrameStartCpu;
        if (durationTicks < 0)
        {
            continue;
        }
        writeFrameEvents(writer, pState, ringIdx, nextRingIdx);
    }
    m_lastFlushedFrameIndex = endFrameIndex;
#endif
}

#ifdef RIVE_MICROPROFILE
namespace
{
std::vector<ArtboardPathSegment> buildArtboardPath(Artboard* artboard,
                                                   RiveProfile* profile)
{
    std::vector<ArtboardPathSegment> pathSegments;
    if (artboard == nullptr || profile == nullptr)
    {
        return pathSegments;
    }
    Artboard* current = artboard;
    while (ArtboardHost* host = current->host())
    {
        ArtboardPathSegment segment;
        if (host->type() == NestedArtboardBase::typeKey)
        {
            auto na = static_cast<NestedArtboard*>(host);
            segment.type = 0;
            segment.nameId = profile->resolveStringId(na->name());
            segment.index = -1;
        }
        else if (host->type() == ArtboardComponentListBase::typeKey)
        {
            auto acl = static_cast<ArtboardComponentList*>(host);
            segment.type = 1;
            segment.nameId = profile->resolveStringId(acl->name());
            segment.index = current->isInstance()
                                ? acl->indexOfArtboardInstance(
                                      static_cast<ArtboardInstance*>(current))
                                : -1;
        }
        else
        {
            break;
        }
        pathSegments.push_back(segment);
        ArtboardPathSegment abSegment;
        abSegment.type = 0;
        abSegment.nameId = profile->resolveStringId(current->name());
        abSegment.index = -1;
        pathSegments.push_back(abSegment);
        current = host->parentArtboard();
        if (current == nullptr)
        {
            break;
        }
    }
    std::reverse(pathSegments.begin(), pathSegments.end());
    return pathSegments;
}
} // namespace
#endif

void RiveProfile::recordTransition(std::string artboardName,
                                   std::string smName,
                                   std::string layerName,
                                   std::string fromStateName,
                                   std::string toStateName,
                                   Artboard* artboardForPath)
{
#ifdef RIVE_MICROPROFILE
    if ((m_logFlags & ProfileLogTransitionRecords) == 0)
        return;
    if (!isActive() || !m_flushCallback)
        return;
    TransitionRecord rec;
    rec.artboardId = resolveStringId(artboardName);
    rec.smId = resolveStringId(smName);
    rec.layerId = resolveStringId(layerName);
    rec.fromStateId = resolveStringId(fromStateName);
    rec.toStateId = resolveStringId(toStateName);
    rec.tick = MP_TICK();
    if (artboardForPath != nullptr)
        rec.path = buildArtboardPath(artboardForPath, this);
    m_transitionRecords.push_back(std::move(rec));
#endif
}

uint32_t RiveProfile::resolveStringId(const std::string& str)
{
#ifdef RIVE_MICROPROFILE
    auto it = m_stringTable.find(str);
    if (it != m_stringTable.end())
    {
        return it->second;
    }
    const uint32_t id = static_cast<uint32_t>(m_stringList.size());
    m_stringTable[str] = id;
    m_stringList.push_back(str);
    return id;
#else
    (void)str;
    return 0;
#endif
}

const std::vector<std::string>& RiveProfile::getStringTable() const
{
    return m_stringList;
}

void RiveProfile::setFlushCallback(FlushCallback callback)
{
    m_flushCallback = std::move(callback);
}

void RiveProfile::flushTransitionRecords()
{
    if (m_flushCallback && !m_transitionRecords.empty())
    {
        m_flushCallback(m_transitionRecords);
    }
    m_transitionRecords.clear();
}

void RiveProfile::recordListenerPerformChange(std::string artboardName,
                                              std::string smName,
                                              std::string listenerName,
                                              uint32_t listenerType,
                                              uint32_t hitEvent,
                                              uint32_t pointerId)
{
#ifdef RIVE_MICROPROFILE
    if ((m_logFlags & ProfileLogListenerPerformChanges) == 0)
        return;
    if (!isActive() || !m_listenerPerformChangeFlushCallback)
        return;
    ListenerPerformChangeRecord rec;
    rec.artboardId = resolveStringId(artboardName);
    rec.smId = resolveStringId(smName);
    rec.listenerNameId = resolveStringId(listenerName);
    rec.listenerType = listenerType;
    rec.hitEvent = hitEvent;
    rec.pointerId = pointerId;
    rec.tick = MP_TICK();
    m_listenerPerformChangeRecords.push_back(std::move(rec));
#else
    (void)artboardName;
    (void)smName;
    (void)listenerName;
    (void)listenerType;
    (void)hitEvent;
    (void)pointerId;
#endif
}

void RiveProfile::setListenerPerformChangeFlushCallback(
    ListenerPerformChangeFlushCallback callback)
{
    m_listenerPerformChangeFlushCallback = std::move(callback);
}

void RiveProfile::flushListenerPerformChangeRecords()
{
    if (m_listenerPerformChangeFlushCallback &&
        !m_listenerPerformChangeRecords.empty())
    {
        m_listenerPerformChangeFlushCallback(m_listenerPerformChangeRecords);
    }
    m_listenerPerformChangeRecords.clear();
}

} // namespace rive