Create()

void Spices::NsightPerfGPUProfilerContinuous::Create

(

VulkanState &

state

)

Begin this Session.

Initialize the periodic sampler.

Create the metrics evaluator.

transfer ownership to m_metricsEvaluator.

Create the config builder, this is used to create a counter configuration.

transfer pRawMetricsConfig's ownership to configBuilder.

Add metrics into config builder.

By setting "keepInstances" to false, the counter data will only store GPU-level values, reducing its size and improving the performance of metric evaluation. However, this option has the drawback of making max/min submetrics non-evaluable.

Create the counter configuration out of the config builder.

Periodic sampler supports only single-pass configurations, meaning that all scheduled metrics must be collectable in a single pass.

Initialize the counter data Below setting determines the maximum size of a counter data image. However, because the counter data here is requested to work in the ring buffer mode, when the put pointer reaches the end, it will start from the beginning and overwrite previous data even if it hasn't been read yet. Therefore, the size specified here must be sufficient to cover the latency.

Update the metrics evaluator with the actual device's attributes stored in the counter data.

Output the header in CSV format.

Start a periodic sampler session.

Apply the previously generated counter configuration to the periodic sampler.

Start sampling. Ideally, sampling should only start right before executing the target workloads to prevent the record buffer from being occupied by records generated by GPU triggers before the target workloads. However, in this use case, it is acceptable because the trigger source is set to "NVPW_GPU_PERIODIC_SAMPLER_TRIGGER_SOURCE_GPU_ENGINE_TRIGGER", which doesn't automatically generate GPU triggers but relies on clients manually pushing triggers through the command list. Furthermore, since the metric configuration used is for low-speed sampling, no "overflow prevention records" will be emitted.

Set InSession true.

Initialize the periodic sampler.

Create the metrics evaluator.

transfer ownership to m_metricsEvaluator.

Create the config builder, this is used to create a counter configuration.

transfer pRawMetricsConfig's ownership to configBuilder.

Add metrics into config builder.

By setting "keepInstances" to false, the counter data will only store GPU-level values, reducing its size and improving the performance of metric evaluation. However, this option has the drawback of making max/min submetrics non-evaluable.

Create the counter configuration out of the config builder.

Periodic sampler supports only single-pass configurations, meaning that all scheduled metrics must be collectable in a single pass.

Initialize the counter data Below setting determines the maximum size of a counter data image. However, because the counter data here is requested to work in the ring buffer mode, when the put pointer reaches the end, it will start from the beginning and overwrite previous data even if it hasn't been read yet. Therefore, the size specified here must be sufficient to cover the latency.

Update the metrics evaluator with the actual device's attributes stored in the counter data.

Output the header in CSV format.

Start a periodic sampler session.

Apply the previously generated counter configuration to the periodic sampler.

Start sampling. Ideally, sampling should only start right before executing the target workloads to prevent the record buffer from being occupied by records generated by GPU triggers before the target workloads. However, in this use case, it is acceptable because the trigger source is set to "NVPW_GPU_PERIODIC_SAMPLER_TRIGGER_SOURCE_GPU_ENGINE_TRIGGER", which doesn't automatically generate GPU triggers but relies on clients manually pushing triggers through the command list. Furthermore, since the metric configuration used is for low-speed sampling, no "overflow prevention records" will be emitted.

Set InSession true.

Definition at line 59 of file NsightPerfGPUProfilerContinuous.cpp.

    {
        SPICES_PROFILE_ZONE;
 
        //NSPERF_CHECK(nv::perf::InitializeNvPerf())
        NSPERF_CHECK(nv::perf::VulkanIsNvidiaDevice(state.m_PhysicalDevice))
        const size_t deviceIndex = nv::perf::VulkanGetNvperfDeviceIndex(state.m_Instance, state.m_PhysicalDevice, state.m_Device);
 
        NSPERF_CHECK(sampler.Initialize(deviceIndex))
        const nv::perf::DeviceIdentifiers deviceIdentifiers = sampler.GetDeviceIdentifiers();
 
        {
            std::vector<uint8_t> metricsEvaluatorScratchBuffer;
            NVPW_MetricsEvaluator* pMetricsEvaluator = nv::perf::sampler::DeviceCreateMetricsEvaluator(metricsEvaluatorScratchBuffer, deviceIdentifiers.pChipName);
 
            metricsEvaluator = nv::perf::MetricsEvaluator(pMetricsEvaluator, std::move(metricsEvaluatorScratchBuffer));
        }
 
        nv::perf::MetricsConfigBuilder configBuilder;
        {
            NVPA_RawMetricsConfig* pRawMetricsConfig = nv::perf::sampler::DeviceCreateRawMetricsConfig(deviceIdentifiers.pChipName);
 
            NSPERF_CHECK(configBuilder.Initialize(metricsEvaluator, pRawMetricsConfig, deviceIdentifiers.pChipName))
        }
 
        for (size_t ii = 0; ii < sizeof(Metrics) / sizeof(Metrics[0]); ++ii)
        {
            const char* const pMetric = Metrics[ii];
            NVPW_MetricEvalRequest request{};
            NSPERF_CHECK(ToMetricEvalRequest(metricsEvaluator, pMetric, request))
 
            
            constexpr bool keepInstances = false;
            NSPERF_CHECK(configBuilder.AddMetrics(&request, 1, keepInstances))
            metricEvalRequests.emplace_back(std::move(request));
        }
 
        nv::perf::CounterConfiguration counterConfiguration;
        NSPERF_CHECK(CreateConfiguration(configBuilder, counterConfiguration))
        
        
        assert(counterConfiguration.numPasses == 1);
 
        constexpr uint32_t MaxSamples = 1024;
        constexpr bool Validate = true; // Setting this to true enables extra validation, which is useful for debugging. In production environments, it can be set to false for improved performance.
        NSPERF_CHECK(counterData.Initialize(
        MaxSamples , 
        Validate   , 
        [&](
            uint32_t                                    maxSamples  , 
            NVPW_PeriodicSampler_CounterData_AppendMode appendMode  , 
            std::vector<uint8_t>&                       counterData
        ) 
        {
            return nv::perf::sampler::GpuPeriodicSamplerCreateCounterData(
                deviceIndex                                   ,
                counterConfiguration.counterDataPrefix.data() ,
                counterConfiguration.counterDataPrefix.size() ,
                maxSamples                                    ,
                appendMode                                    ,
                counterData
            );
        }))
 
        
        NSPERF_CHECK(MetricsEvaluatorSetDeviceAttributes(
            metricsEvaluator                    , 
            counterData.GetCounterData().data() , 
            counterData.GetCounterData().size()
        ))
 
        
        {
            std::cout << "StartTime, EndTime, Duration";
            const auto countersEnumerator    = EnumerateCounters(metricsEvaluator);
            const auto ratiosEnumerator      = EnumerateRatios(metricsEvaluator);
            const auto throughputsEnumerator = EnumerateThroughputs(metricsEvaluator);
            for (const NVPW_MetricEvalRequest& metricEvalRequest : metricEvalRequests)
            {
                std::cout << ", " << ToString(countersEnumerator, ratiosEnumerator, throughputsEnumerator, metricEvalRequest);
            }
            std::cout << "\n";
        }
 
        constexpr size_t SamplingFrequency = 120; // 120 Hz
        constexpr size_t samplingIntervalInNanoSeconds = 1000 * 1000 * 1000 / SamplingFrequency;
        constexpr size_t MaxDecodeLatencyInNanoSeconds = 1000 * 1000 * 1000 * 10; // tolerate maximum DecodeCounters() latency up to 1 second
        const nv::perf::sampler::GpuPeriodicSampler::GpuPulseSamplingInterval samplingInterval = sampler.GetGpuPulseSamplingInterval(samplingIntervalInNanoSeconds);
        const size_t maxNumUndecodedSamples = MaxDecodeLatencyInNanoSeconds / samplingIntervalInNanoSeconds;
        size_t recordBufferSize = 0;
        NSPERF_CHECK(nv::perf::sampler::GpuPeriodicSamplerCalculateRecordBufferSize(deviceIndex, counterConfiguration.configImage, maxNumUndecodedSamples, recordBufferSize))
 
        const size_t MaxNumUndecodedSamplingRanges = 1; // must be 1
        NSPERF_CHECK(sampler.BeginSession(
            recordBufferSize                   ,
            MaxNumUndecodedSamplingRanges      ,
            { samplingInterval.triggerSource } ,
            samplingInterval.samplingInterval
        ))
 
        
        constexpr size_t passIndex = 0; // This is a single-pass configuration, so the pass index is fixed at 0.
        NSPERF_CHECK(sampler.SetConfig(counterConfiguration.configImage, passIndex))
 
        NSPERF_CHECK(sampler.StartSampling())
 
        m_IsInSession = true;
    }

References m_IsInSession.

Referenced by BeginFrame(), and NsightPerfGPUProfilerContinuous().