gpu_audio_status.hpp

Go to the documentation of this file.

#pragma once
 
#include <cstdint>
 
namespace pulp::gpu_audio {
 
// Defined in gpu_audio_node.hpp and gpu_audio_capability.hpp, which include
// this header: GpuAudioNode::status_snapshot() returns GpuAudioStatus by value,
// so the status definition cannot depend on the node header being complete.
enum class MissPolicy;
enum class GpuAudioProvider : std::uint8_t;

enum class GpuAudioEngine : std::uint8_t {
    Unknown = 0,
    Cpu = 1,
    Gpu = 2,
};

enum class GpuAudioProviderState : std::uint8_t {
    Uninitialized = 0,
    Ready = 1,
    Degraded = 2,
    Unavailable = 3,
};

enum class GpuAudioRecoveryReason : std::uint8_t {
    None = 0,
    SequenceGap = 1,
    InputSaturated = 2,
    ProviderFailure = 3,
    ProviderLost = 4,
    OfflineFence = 5,
    InvalidCallback = 6,
    ProviderUnresponsive = 7,
    ProviderReacquired = 8,
    SustainedDeadlineMisses = 9,
};

enum class GpuAudioCompletionMode : std::uint8_t {
    Unknown = 0,
    ProcessEvents = 1,
    WaitAny = 2,
    TimedWaitAny = 3,
};

enum class GpuAudioShadowMode : std::uint8_t {
    None = 0,
    Inline = 1,
    Worker = 2,
};

struct GpuAudioStatus {
    static constexpr std::uint32_t kSchemaVersion = 4;
    static constexpr std::uint32_t kTerminalDispositionCount = 8;
 
    std::uint32_t schema_version = kSchemaVersion;
    GpuAudioEngine requested_engine = GpuAudioEngine::Unknown;
    GpuAudioEngine selected_engine = GpuAudioEngine::Unknown;
    GpuAudioProviderState provider_state = GpuAudioProviderState::Uninitialized;
    GpuAudioProvider provider = GpuAudioProvider{}; // GpuAudioProvider::Unknown
    MissPolicy fallback_policy = MissPolicy{};      // MissPolicy::Silence
 
    std::uint32_t sample_rate = 0;
    std::uint32_t block_size = 0;
    std::uint32_t latency_samples = 0;
    std::uint32_t prepared_lead_blocks = 0;
    bool fallback_available = false;
    bool diagnostics_available = false;
    std::uint64_t produced_blocks = 0;
    std::uint64_t missed_blocks = 0;
    std::uint64_t fallback_blocks = 0;
    std::uint64_t resynced_blocks = 0;
    std::uint64_t input_dropped_frames = 0;
    double last_block_us = 0.0;
    double avg_block_us = 0.0;
    // Appended after the v1 fields so positional aggregate initialization of
    // the installed status prefix remains source-compatible.
    GpuAudioRecoveryReason recovery_reason = GpuAudioRecoveryReason::None;
    std::uint64_t recovery_sequence = UINT64_MAX;
    // Schema v3, appended after the v2 fields for the same reason.
    std::uint64_t epoch = 0;
    bool delivery_epoch_active = false;
    std::uint64_t terminal_counts[kTerminalDispositionCount] = {};
    GpuAudioCompletionMode completion_mode = GpuAudioCompletionMode::Unknown;
    bool timestamps_available = false;
    std::uint64_t last_delivery_ns = 0;
    bool gpu_kernel_available = false;
    // CPU shadow reporting. Still schema v3: these were appended before any
    // release carried v3, so kSchemaVersion does not move for them.
    GpuAudioShadowMode shadow_mode = GpuAudioShadowMode::None;
    float shadow_inline_cost_pct = 0.0f;
    std::uint64_t shadow_delivered_blocks = 0;
    std::uint64_t shadow_late_blocks = 0;
    std::uint64_t shadow_double_miss_blocks = 0;
    bool shadow_model_differs = false;
    // Schema v4: automatic re-acquire (GpuAudioRecoveryPolicy::AutoReacquire).
    std::uint64_t reacquire_attempts = 0;
    std::uint64_t reacquire_successes = 0;
    std::uint64_t last_reacquire_to_gpu_ns = 0;
};
 
} // namespace pulp::gpu_audio
 
// Kept for consumers that reach the capability and node types through this
// header; included last because those headers include this one.
#include <pulp/gpu_audio/gpu_audio_capability.hpp>