fusion.h

#pragma once
 
#include "backend/types.h"   // fz::stream_t
#include <cstddef>
#include <cstdint>
#include <string>
#include <vector>
 
namespace fz {
 
class MemoryPool;
 
enum class FusionAccess : uint8_t {
    Unfusable = 0,
    Map,
    BlockLocal,
    TileAdaptive,
    Cooperative,
};
 
struct FusionSpec {
    FusionAccess access = FusionAccess::Unfusable;
    uint32_t block_size = 0;
    uint32_t coder_unit_size = 0;
 
    bool fusable() const { return access != FusionAccess::Unfusable; }
};
 
enum class FusionStrategy : uint8_t {
    ChunkCooperative,
    WarpRegister,
};
 
enum class EncodingOracleKind : uint8_t {
    None = 0,
    PlainFixedRateBitpack,
    AdaptiveFixedRateBitpack,
};
 
struct EncodingOracleDecl {
    EncodingOracleKind   kind = EncodingOracleKind::None;
    std::string          op_name;
    std::string          include_header;
    std::vector<uint8_t> params;
    uint8_t              input_data_type = 0xFF; 
    uint32_t             unit_elems = 0;
    bool                 exact = false;
    bool                 additive = false;
 
    bool valid() const {
        return kind != EncodingOracleKind::None && !op_name.empty() &&
               unit_elems != 0 && exact;
    }
};
 
enum class FusedAuxSizeKind : uint8_t {
    FixedBitsPerUnit = 0, 
    CompactedElements,   
};
 
struct FusedAuxOutputDecl {
    int                  output_index = -1;
    std::string          name;
    FusedAuxSizeKind     size_kind = FusedAuxSizeKind::CompactedElements;
    uint8_t              data_type = 0xFF;
    uint32_t             unit_elems = 0;
    uint32_t             bits_per_unit = 0;
    uint32_t             count_group = 0; 
 
    bool valid() const {
        if (output_index < 0 || name.empty() || unit_elems == 0) return false;
        return size_kind != FusedAuxSizeKind::FixedBitsPerUnit || bits_per_unit != 0;
    }
};
 
struct FusedOpDecl {
    FusionStrategy       strategy = FusionStrategy::ChunkCooperative;
    std::string          op_name;         
    std::string          include_header;  
    std::vector<uint8_t> params;          
 
    uint32_t             elems_per_lane = 0;
    size_t               n_ab = 0;
    bool valid() const { return !op_name.empty(); }
};
 
struct FusedPrimeContext {
    const void*  d_input     = nullptr;  
    size_t       input_bytes = 0;        
    MemoryPool*  pool        = nullptr;  
    fz::stream_t stream      = nullptr;  
};
 
} // namespace fz