are_tokens_compatible()

bool MayaFlux::Buffers::are_tokens_compatible ( ProcessingToken  preferred, ProcessingToken  current  )

inline

Determines if two processing tokens are compatible for joint execution.

Parameters

preferred	The preferred processing token configuration
current	The current processing token configuration being evaluated

Returns

true if the tokens are compatible, false otherwise

This function implements sophisticated compatibility logic that goes beyond simple equality checking to determine if processors with different token requirements can work together in the same processing pipeline. The compatibility rules are designed to maximize processing flexibility while maintaining system stability and performance.

Rate Compatibility Rules:

• FRAME_RATE processors require FRAME_RATE execution contexts (strict requirement)
• SAMPLE_RATE processors can adapt to FRAME_RATE contexts (flexible upward compatibility)
• Same-rate combinations are always compatible

Device Compatibility Rules:

• SAMPLE_RATE processing cannot execute on GPU hardware (hardware limitation)
• GPU-preferred processors cannot fall back to CPU execution (performance requirement)
• CPU-preferred processors can use GPU for FRAME_RATE processing only

Concurrency Compatibility Rules:

• Sequential/Parallel differences are acceptable if rate requirements align
• Mismatched concurrency with incompatible rates is rejected
• Same concurrency patterns are always compatible

This flexibility enables the system to optimize processing chains by allowing compatible processors to share execution contexts while preventing configurations that would result in poor performance or execution failures.

Definition at line 139 of file BufferUtils.hpp.

{
    bool preferred_sample = preferred & SAMPLE_RATE;
    bool preferred_frame = preferred & FRAME_RATE;
    bool current_sample = current & SAMPLE_RATE;
    bool current_frame = current & FRAME_RATE;
 
    // If preferred is FRAME_RATE, only FRAME_RATE is compatible
    if (preferred_frame && !current_frame)
        return false;
    // If preferred is SAMPLE_RATE, FRAME_RATE can be compatible (sample can "delay" to frame)
    if (preferred_sample && current_frame)
        return true;
    // If both are SAMPLE_RATE or both are FRAME_RATE, compatible
    if ((preferred_sample && current_sample) || (preferred_frame && current_frame))
        return true;
 
    // Device compatibility: SAMPLE_RATE can't run on GPU, but FRAME_RATE can run on CPU
    bool preferred_cpu = preferred & CPU_PROCESS;
    bool preferred_gpu = preferred & GPU_PPOCESS;
    bool current_cpu = current & CPU_PROCESS;
    bool current_gpu = current & GPU_PPOCESS;
 
    if (preferred_sample && current_gpu)
        return false; // Can't run sample rate on GPU
    if (preferred_gpu && current_cpu)
        return false; // If preferred is GPU, but current is CPU, not compatible
    // If preferred is CPU, but current is GPU, allow only for FRAME_RATE
    if (preferred_cpu && current_gpu && !current_frame)
        return false;
 
    // Sequential/Parallel compatibility: allow if rates align
    bool preferred_seq = preferred & SEQUENTIAL;
    bool preferred_par = preferred & PARALLEL;
    bool current_seq = current & SEQUENTIAL;
    bool current_par = current & PARALLEL;
 
    if ((preferred_seq && current_par) || (preferred_par && current_seq)) {
        // Allow if rates align (already checked above)
        if ((preferred_sample && current_sample) || (preferred_frame && current_frame))
            return true;
        // If preferred is SAMPLE_RATE and current is FRAME_RATE, already handled above
        // Otherwise, not compatible
        return false;
    }
 
    // If all checks pass, compatible
    return true;
}

References CPU_PROCESS, FRAME_RATE, GPU_PPOCESS, PARALLEL, SAMPLE_RATE, and SEQUENTIAL.

Referenced by MayaFlux::Buffers::BufferProcessingChain::add_processor_direct(), MayaFlux::Buffers::BufferProcessingChain::analyze_token_compatibility(), MayaFlux::Buffers::BufferProcessingChain::enforce_chain_token_on_processors(), MayaFlux::Buffers::RootBuffer< BufferType >::is_buffer_acceptable(), MayaFlux::Buffers::ChannelProcessor::on_attach(), MayaFlux::Buffers::FinalLimiterProcessor::on_attach(), MayaFlux::Buffers::GraphicsBatchProcessor::on_attach(), MayaFlux::Buffers::PresentProcessor::on_attach(), MayaFlux::Buffers::BufferProcessingChain::optimize_for_tokens(), MayaFlux::Buffers::BufferProcessingChain::process(), MayaFlux::Buffers::BufferProcessingChain::process_non_owning(), and MayaFlux::Buffers::BufferProcessingChain::validate_all_processors().

Here is the caller graph for this function: