EndFrame()

void Spices::NsightPerfGPUProfilerContinuous::EndFrame

(

)

ConsumeSample each frame.

Decode the record buffer and store the decoded counters into the counter data.

Inform counter data to stop iterating because all existing data has been consumed.

Reset after out.

Decode the record buffer and store the decoded counters into the counter data.

Inform counter data to stop iterating because all existing data has been consumed.

Reset after out.

Definition at line 232 of file NsightPerfGPUProfilerContinuous.cpp.

    {
        SPICES_PROFILE_ZONE;
 
        if (!m_IsInSession) return;
 
        nv::perf::sampler::GpuPeriodicSampler::GetRecordBufferStatusParams getRecordBufferStatusParams = {};
        getRecordBufferStatusParams.queryOverflow       = true;
        getRecordBufferStatusParams.queryNumUnreadBytes = true;
        const bool success = sampler.GetRecordBufferStatus(getRecordBufferStatusParams);
        if (!success)
        {
            return;
        }
        if (getRecordBufferStatusParams.overflow)
        {
            SPICES_CORE_ERROR("Record buffer has overflowed. Please ensure that the value of `maxNumUndecodedSamples` is sufficiently large.")
        }
 
        if (getRecordBufferStatusParams.numUnreadBytes == 0)
        {
            return;
        }
 
        NVPW_GPU_PeriodicSampler_DecodeStopReason decodeStopReason = NVPW_GPU_PERIODIC_SAMPLER_DECODE_STOP_REASON_OTHER;
        size_t numSamplesMerged = 0;
        size_t numBytesConsumed = 0;
        if (!sampler.DecodeCounters(
            counterData.GetCounterData()               ,
            getRecordBufferStatusParams.numUnreadBytes ,
            decodeStopReason                           ,
            numSamplesMerged                           ,
            numBytesConsumed
        ))
        {
            SPICES_CORE_WARN("Failed to decode counters.")
        }
 
        if (numSamplesMerged)
        {
            SPICES_CORE_WARN("Samples appear to be merged, this can reduce the accuracy of the collected samples. Please check for any back-to-back triggers!")
        }
        if (decodeStopReason != NVPW_GPU_PERIODIC_SAMPLER_DECODE_STOP_REASON_ALL_GIVEN_BYTES_READ)
        {
            SPICES_CORE_WARN("DecodeCounters stopped unexpectedly.")
        }
        if (!sampler.AcknowledgeRecordBuffer(numBytesConsumed))
        {
            SPICES_CORE_WARN("Failed to acknowledge record buffer")
        }
        if (!counterData.UpdatePut())
        {
            SPICES_CORE_WARN("Failed to update counter data's put pointer.")
        }
 
        const uint32_t numUnreadRanges = counterData.GetNumUnreadRanges();
        if (numUnreadRanges)
        {
            std::vector<double> metricValues(metricEvalRequests.size());
            uint32_t numRangesConsumed = 0;
            NSPERF_CHECK(counterData.ConsumeData(
            [&](
                const uint8_t* pCounterDataImage    , 
                size_t         counterDataImageSize , 
                uint32_t       rangeIndex           , 
                bool&          stop
            ) 
            {
                nv::perf::sampler::SampleTimestamp timestamp{};
                if (!CounterDataGetSampleTime(pCounterDataImage, rangeIndex, timestamp))
                {
                    return false;
                }
 
                if (!nv::perf::EvaluateToGpuValues(
                    metricsEvaluator,
                    pCounterDataImage,
                    counterDataImageSize,
                    rangeIndex,
                    metricEvalRequests.size(),
                    metricEvalRequests.data(),
                    metricValues.data()))
                {
                    return false;
                }
                {
                    std::cout << std::fixed << std::setprecision(0) << timestamp.start << ", " << timestamp.end << ", " << (timestamp.end - timestamp.start);
                    for (const double& metricValue : metricValues)
                    {
                        std::cout << ", " << metricValue;
                    }
                    std::cout << "\n";
                }
                if (++numRangesConsumed == numUnreadRanges)
                {
                    stop = true;
                }
                return true;
            }))
 
            std::cout << std::flush;
            if (!counterData.UpdateGet(numRangesConsumed))
            {
                SPICES_CORE_WARN("Counter data failed to update get pointer.")
            }
        }
 
        Reset();
    }

References m_IsInSession, and Reset().