// cam_feature 新增
int64_t memLen;

constexpr int CAM_MAX_RANK_SIZE = 384;              // 最大 NPU 卡数
constexpr int64_t IPC_BUFF_MAX_SIZE = 100 * 1024 * 1024;  // IPC 缓冲区 100MB
constexpr int64_t IPC_DATA_OFFSET = 2 * 1024 * 1024;      // 前 2MB 为 flag，后 100MB 为数据
constexpr int64_t UB_SINGLE_DMA_SIZE_MAX = 190 * 1024;    // UB 单次 DMA 最大 190KB
constexpr int64_t UB_SINGLE_PING_PONG_ADD_SIZE_MAX = UB_SINGLE_DMA_SIZE_MAX / 2;  // Ping-Pong 半区
constexpr int UB_ALIGN_SIZE = 32;                         // UB 对齐 32B
constexpr uint8_t COMM_NUM = 2;   // 通信域数量（EP + TP）
constexpr uint8_t COMM_EP_IDX = 0;
constexpr uint8_t COMM_TP_IDX = 1;
constexpr int64_t STATE_WIN_OFFSET = 900 * 1024;  // 状态窗口偏移
constexpr int64_t UB_SINGLE_TOTAL_SIZE_MAX = 192 * 1024;  // UB 总大小 192KB
constexpr int64_t START_OFFSET_FOR_SHARE = 512;    // 共享区域起始偏移

enum Op : int {
    COPYONLY = -1,
    ADD = 0,
    MUL = 1,
    MAX = 2,
    MIN = 3
};

__aicore__ inline void InitDetour(int rank, int rankSize, GM_ADDR *shareAddrs,
                                  int64_t shareMemOffset, TBuf<QuePosition::VECCALC> &tBuf)
{
    // ...
    localSyncAddr = (__gm__ int64_t*)(shareAddrs[rank] + shareMemOffset);
    basicSyncAddr = (__gm__ int64_t*)(shareAddrs[rank] + shareMemOffset) + GetBlockIdx() * FLAG_UNIT_INT_NUM;
    blockOuterSyncAddr = (__gm__ int64_t*)(shareAddrs[rank] + shareMemOffset) + segmentCount + GetBlockIdx() * FLAG_UNIT_INT_NUM;
    // ...
}

__aicore__ inline void WaitSyncFlag(int32_t magic, int32_t value, int32_t eventID,
                                     int32_t rank, int64_t flagNum, int64_t offset)
{
    int64_t v = MergeMagicWithValue(magic, value);
    WaitOneRankPartFlag((__gm__ int64_t*)(shareAddrs[rank] + offset) + eventID * FLAG_UNIT_INT_NUM, flagNum, v);
}

__aicore__ inline void SetOuterFlagDetour(int32_t magic, int32_t eventID,
    int64_t setRank, int64_t setBlock, int64_t shareMemOffset)
{
    __gm__ int64_t* flagAddr = GetOuterFlagAddrDetour(setRank, setBlock, shareMemOffset);
    int64_t value = MergeMagicWithValue(magic, eventID);
    SetFlag(flagAddr, value);
}

__aicore__ inline void WaitOuterFlagDetour(int32_t magic, int32_t eventID,
    int64_t waitRank, int64_t waitBlock, int64_t shareMemOffset)
{
    int64_t value = MergeMagicWithValue(magic, eventID);
    __gm__ int64_t* flagAddr = GetOuterFlagAddrDetour(waitRank, waitBlock, shareMemOffset);
    WaitOneRankPartFlag(flagAddr, 1, value);
}

__aicore__ inline __gm__ int64_t* GetOuterFlagAddrDetour(int64_t flagRank, int64_t flagBlock, int64_t shareMemOffset)
{
    return (__gm__ int64_t*)(shareAddrs[flagRank] + shareMemOffset) + segmentCount + flagBlock * FLAG_UNIT_INT_NUM;
}

共享内存窗口 (peerMems[rank])
├── [0, segmentCount * FLAG_UNIT_INT_NUM * 8)     ← Memory A: 卡内同步 flag
│   ├── block 0: [flag0, flag1, flag2, flag3]       (FLAG_UNIT_INT_NUM = 4)
│   ├── block 1: [flag0, flag1, flag2, flag3]
│   └── ...
├── [segmentCount * 4 * 8, ...)                    ← Memory B: 卡间同步 flag
│   ├── block 0: [flag0, flag1, flag2, flag3]
│   └── ...
└── [IPC_CHUNK_FLAG, ...)                          ← Chunk Flag 区域 (IPC 用)

constexpr uint32_t LOCAL_NOTIFY_MAX_NUM = 64;     // 最大本地 notify 数
constexpr uint32_t LOCAL_STREAM_MAX_NUM = 19;     // 最大本地 stream 数
constexpr uint32_t AICPU_OP_NOTIFY_MAX_NUM = 2;   // AICPU notify 数
constexpr uint32_t AICPU_MAX_RANK_NUM = 128 * 1024;  // AICPU 最大 rank 数

namespace Moe {
constexpr uint64_t COMBINE_STATE_WIN_OFFSET = 4U * 1024UL * 1024UL;       // 4MB
constexpr uint64_t NOTIFY_DISPATCH_WIN_OFFSET = 204U * 1024UL * 1024UL;   // 204MB
} // namespace Moe

class Mc2TilingUtils {
public:
    static uint64_t GetMaxWindowSize() {
        uint16_t defaultWindowSize = 200;  // 默认 200MB
        if (getenv("HCCL_BUFFSIZE") != nullptr) {
            try {
                std::string envStr(getenv("HCCL_BUFFSIZE"));
                defaultWindowSize = std::stoi(envStr);
            } catch (...) { /* 异常处理 */ }
        }
        return static_cast<uint64_t>(defaultWindowSize) * 1024UL * 1024UL;
    }
};

class DfxBase {
public:
    static constexpr const int MAX_LOG_LEN = 16000;
    static constexpr const int MSG_HDR_LEN = 200;
    static inline uint64_t GetTid();                          // 获取线程 ID
    static inline std::string GetOpInfo(const gert::TilingContext *context);  // 获取算子信息
    // ... 支持 TilingContext / TilingParseContext / InferShapeContext / InferDataTypeContext
};

#define OPS_LOG_STUB(MOD_ID, LOG_LEVEL, OPS_DESC, FMT, ...)
// 统一日志记录，包含文件名、行号、函数名、TID、算子名

#define OPS_INNER_ERR_STUB(ERR_CODE_STR, OPS_DESC, FMT, ...)
// 内部错误报告 + 日志

#define OPS_CALL_ERR_STUB(ERR_CODE_STR, OPS_DESC, FMT, ...)
// 调用错误报告 + 日志

#define OPS_LOG_D(OPS_DESC, ...) OPS_LOG_STUB_D(OPS_DESC, __VA_ARGS__)    // Debug
#define OPS_LOG_I(OPS_DESC, ...) OPS_LOG_STUB_I(OPS_DESC, __VA_ARGS__)    // Info
#define OPS_LOG_W(OPS_DESC, ...) OPS_LOG_STUB_W(OPS_DESC, __VA_ARGS__)    // Warn
#define OPS_LOG_E(OPS_DESC, ...) OPS_INNER_ERR_STUB("EZ9999", OPS_DESC, __VA_ARGS__)  // Error + Report
#define OPS_LOG_EVENT(OPS_DESC, ...) OPS_LOG_STUB_EVENT(OPS_DESC, __VA_ARGS__)  // Event

#define OPS_LOG_D_IF(COND, OP_DESC, EXPR, ...)
#define OPS_LOG_E_IF_NULL(OPS_DESC, PTR, EXPR)  // 空指针检查 + 错误报告

#define OPS_REPORT_VECTOR_INNER_ERR(OPS_DESC, ...) OPS_INNER_ERR_STUB("E89999", OPS_DESC, __VA_ARGS__)
#define OPS_REPORT_CUBE_INNER_ERR(OPS_DESC, ...) OPS_INNER_ERR_STUB("E69999", OPS_DESC, __VA_ARGS__)
#define OPS_ERR_IF(COND, LOG_FUNC, EXPR) OPS_LOG_STUB_IF(COND, LOG_FUNC, EXPR)

#define OP_LOGI(opname, ...)          // Info 级别（空实现）
#define OP_LOGW(opname, ...)          // Warn 级别（printf）
#define OP_LOGE_WITHOUT_REPORT(opname, ...)  // Error 不报告
#define OP_LOGE(opname, ...)          // Error 级别（printf）
#define OP_LOGD(opname, ...)          // Debug 级别（空实现）

template <typename K, typename U = K>
FORCE_INLINE_AICORE void CpGM2GMPingPong(int64_t dataSizeRemain,
    const GlobalTensor<U> &sendDataInputGt,
    const GlobalTensor<K> &recvDataOutputGT, int op)

template <typename T> void CpUB2GM(__gm__ T *gmAddr, __ubuf__ T *ubAddr, uint32_t size);
template <typename T> void CpGM2UB(__ubuf__ T *ubAddr, __gm__ T *gmAddr, uint32_t size);
template<typename T> void CopyUB2UB(__ubuf__ T *dst, __ubuf__ T *src, const uint32_t calCount);
template<typename T> void copyGmToGmWithBlocks(...);  // 多核分块 GM→GM

{
  "soc_versions": {
    "ascend910_93": [
      "dispatch_layout",
      "fused_deep_moe",
      "moe_combine_normal",
      "moe_dispatch_normal",
      "notify_dispatch"
    ]
  },
  "operator_meta": {
    "dispatch_layout": { "requires_shmem": false },
    "fused_deep_moe": { "requires_shmem": false, "family": "fused_deep_moe", "variant": "base" },
    "moe_combine_normal": { "requires_shmem": false },
    "moe_dispatch_normal": { "requires_shmem": false },
    "notify_dispatch": { "requires_shmem": false }
  }
}

{
  "soc_versions": {
    "ascend910_93": [
      "a2e",
      "all_to_all_detour",
      "e2a",
      "fused_deep_moe",
      "fused_deep_moe_fwk",
      "fused_deep_moe_w4a8",
      "moe_combine_lowlatency_zb",
      "moe_combine_normal_zb",
      "moe_dispatch_layout_zb",
      "moe_dispatch_lowlatency_zb",
      "moe_dispatch_normal_zb",
      "moe_notify_dispatch_zb",
      "reduce_scatter_detour"
    ]
  }
}

fused_deep_moe (base) ──┐
                         ├── 互斥（共享 fused_deep_moe.* 文件名）
fused_deep_moe_w4a8 ────┘

fused_deep_moe_fwk ───── 独立（fused_deep_moe_fwk.* 文件名），可与 base/w4a8 共存

输入: registry, soc_list, shmem, quant, user_ops
  │
  ├─ 1. 确定候选集: user_ops 或全量 soc_list
  │
  ├─ 2. fused_deep_moe 互斥规则
  │   ├─ quant=true: 强制 w4a8，移除 base
  │   ├─ quant=false + 两者都在: 保留 base，移除 w4a8
  │   └─ fwk 不受影响
  │
  ├─ 3. SHMEM 过滤
  │   └─ shmem=false: 移除所有 requires_shmem=true 的算子
  │
  └─ 4. 按注册表顺序排序输出

python3 select_ops.py \
    --registry operator_registry.json \
    --soc ascend910_93 \
    --shmem 1 \
    --quant \
    --ops "a2e;e2a;fused_deep_moe"

shmem_installed=1
if [ -z "${SHMEM_HOME_PATH}" ]; then
    shmem_installed=0
fi

# Patch kernel compile .make files to pass custom include paths to OPC tool.
KERNEL_COMPILE_OPTS=""
if [ -n "${SHMEM_HOME_PATH}" ]; then
    KERNEL_COMPILE_OPTS="-I${SHMEM_HOME_PATH}/shmem/include -I${SHMEM_HOME_PATH}/shmem/src/device"
fi
if [ -n "${CATLASS_HOME_PATH}" ]; then
    KERNEL_COMPILE_OPTS="${KERNEL_COMPILE_OPTS}-I${CATLASS_HOME_PATH}/include"
fi
if [ -n "${KERNEL_COMPILE_OPTS}" ]; then
    find build_out/op_kernel/CMakeFiles -name "build.make" \
        -exec sed -i "s|--compile-options=\"\"|--compile-options=\\\"${KERNEL_COMPILE_OPTS}\\\"|g" {} +
fi

copy_ops_include() {
    # 始终复制 utils 公共头目录
    cp -rf "$src_dir/utils/op_host/"* "$dst_dir/op_host/"
    cp -rf "$src_dir/utils/op_kernel/"* "$dst_dir/op_kernel/"

    # 仅复制选中算子的 op_host/op_kernel/op_api
    for name in "${ops[@]}"; do
        cp -rf "$subdir/op_host/"* "$dst_dir/op_host/"
        cp -rf "$subdir/op_kernel/"* "$dst_dir/op_kernel/"
        cp -rf "$subdir/op_api/"* "$dst_dir/pregen/build_out/autogen/"
    done
}

# master（有 bug）
options.append("-I" + SHMEM_HOME_PATH + "shmem/include/device")  # 缺少 / 分隔符

# cam_feature（修复）
options.append("-I" + SHMEM_HOME_PATH + "/shmem/include/device")  # 正确路径

options.append("-I" + SHMEM_HOME_PATH + "/shmem/include")
options.append("-I" + SHMEM_HOME_PATH + "/shmem/include/device")
options.append("-I" + SHMEM_HOME_PATH + "/shmem/include/host_device")
options.append("-I" + SHMEM_HOME_PATH + "/shmem/include/internal")
options.append("-I" + SHMEM_HOME_PATH + "/shmem/src")
options.append("-I" + SHMEM_HOME_PATH + "/shmem/src/device")
options.append("-I" + SHMEM_HOME_PATH + "/memfabric_hybrid/include/smem/device")

# cam_feature 新增
list(APPEND KERNEL_COMPILE_OPTS -I${CMAKE_CURRENT_SOURCE_DIR} -DASCENDC_DUMP=0 --cce-auto-sync=off -DCATLASS_ARCH=2201)

set(CANN83_PATH "${CANN_ROOT}/include/platform/platform_infos_def.h")
set(CANN82_PATH "${CANN_ROOT}/include/experiment/platform/platform/platform_infos_def.h")

if(EXISTS "${CANN83_PATH}")
    add_definitions(-DUSE_CANN83_PATH)
elseif(EXISTS "${CANN82_PATH}")
    add_definitions(-DUSE_CANN82_PATH)
endif()

cmake_minimum_required(VERSION 3.16.0)
project(opp)
find_package(ASC REQUIRED)
set(package_name ${vendor_name})

npu_op_package(${package_name} TYPE RUN CONFIG INSTALL_PATH ${CMAKE_BINARY_DIR}/)

add_subdirectory(op_host)
add_subdirectory(op_kernel)

hfa/
├── .gitignore
├── CMakeLists.txt
├── README.md
├── doc/
│   └── HFA.pdf
├── include/
│   └── hbm_fast_alloc.h        ← 对外头文件
├── src/
│   ├── CMakeLists.txt
│   ├── acl_free_chunks.cpp     ← 空闲块管理
│   ├── acl_virtual_memory.cpp  ← 虚拟内存管理
│   ├── acl_virtual_memory.h    ← 虚拟内存头文件
│   ├── flex_alloc.cpp          ← 弹性分配器
│   ├── flex_alloc.h            ← 弹性分配器头文件
│   ├── hbm_fast_alloc.cpp      ← HBM 快速分配器
│   └── hfa_log.h               ← 日志工具
└── test/

class FlexAlloc {
private:
    struct Range { length_t size; };

    // 主索引：按起始偏移排序
    using StartMap = std::map<offset_t, Range>;
    // 辅助索引：按大小排序，值为 StartMap 的迭代器
    using SizeMap = std::multimap<length_t, typename StartMap::iterator>;

    StartMap m_free_ranges_by_offset;   // 按偏移索引的空闲区间
    SizeMap  m_free_ranges_by_size;     // 按大小索引的空闲区间
    size_t m_mem_size { 0 };
    size_t m_total_alloc_bytes { 0 };
    size_t m_total_free_bytes { 0 };
    size_t m_total_alloc_objs { 0 };
};

FlexAlloc::FlexRetCode FlexAlloc::alloc(length_t req_size, size_t &offset, size_t &alloc_size)
{
    alloc_size = round_up_bits(req_size, OBJ_SIZE_BITS);  // 64 字节对齐

    // 1. 在 SizeMap 中查找第一个 >= alloc_size 的区间
    auto sizeIt = m_free_ranges_by_size.lower_bound(alloc_size);

    // 2. 如果没找到，区分"内存不足"和"碎片化"
    if (sizeIt == m_free_ranges_by_size.end()) {
        if (get_total_free_mem() >= alloc_size)
            return FLEX_RC_ERR_FRAGMENTATION;  // 总空闲够但无连续块
        else
            return FLEX_RC_ERR_NO_MEM;         // 总空闲不够
    }

    // 3. 分配并分割剩余
    offset = rangeIt->first;
    blkSz = rangeIt->second.size;
    // 从两个索引中删除
    // 如果有剩余，将新区间插回两个索引
}

bool FlexAlloc::free(offset_t offset, length_t size)
{
    // 1. 查找第一个起始位置 >= offset 的区间
    auto next = m_free_ranges_by_offset.lower_bound(offset);

    // 2. 尝试与前一个区间合并
    if (prevEnd == offset) { /* 合并 */ }

    // 3. 尝试与后一个区间合并
    while (newStart + newSize == rangeStart) { /* 合并 */ }

    // 4. 插入合并后的区间
}

static size_t const OBJ_SIZE_BITS = 6;           // 2^6 = 64 字节对齐
static size_t const MIN_OBJ_SIZE = (1UL << OBJ_SIZE_BITS);  // 最小 64 字节

template <typename T>
T round_up_bits(T num, uint32_t nbits) {
    T shift = ((static_cast<T>(1)) << nbits) - 1;
    return (num + shift) & ~(shift);
}

enum FlexRetCode {
    FLEX_RC_SUCCESS,            // 成功
    FLEX_RC_ERROR,              // 通用错误
    FLEX_RC_ERR_INVAL_ARG,      // 无效参数
    FLEX_RC_ERR_NO_MEM,         // 内存不足
    FLEX_RC_ERR_FRAGMENTATION   // 碎片化（总空闲够但无连续块）
};

class AclVirtualMemory {
public:
    // 分配 HBM 内存：虚拟内存最大 128GB，物理内存最大 32GB
    std::pair<VmRet, void*> alloc(int32_t device_id, size_t vr_mem_size,
                                   size_t ph_mem_size, size_t ph_page_size);

    // 碎片整理：将分散的物理页重新映射为连续块
    VmRet defrag(AclFreeChunks* p_free_chunks);

    void* get_base_addr() { return mp_vr_base_addr; }
    void free();
};

const size_t MAX_VIRTUAL_MEM_SIZE = 128UL * 1024 * 1024 * 1024;  // 128GB
const size_t PH_PAGE_ALIGN_SIZE = 2 * 1024 * 1024;               // 2MB 页对齐
const size_t DEF_INITIAL_FREE_PAGES = 1024;
const size_t DEF_INITIAL_FREE_CHUNKS = 1024;

输入: 空闲块列表 (AclFreeChunks)
  │
  ├─ 1. 遍历每个空闲块，提取完整物理页
  │   ├─ 对齐的首页 → 加入 free_pages
  │   ├─ 对齐的尾页 → 加入 free_pages
  │   └─ 中间完整页 → 加入 free_pages
  │
  ├─ 2. 重新映射完整页到虚拟内存末尾
  │   for each page in free_pages:
  │     if 完整页: aclrtMapMem 到末尾
  │     else: 作为不完整块保留
  │
  └─ 3. 输出: 一个连续大块 + 若干不完整边块

enum class VmRet {
    SUCCESS = 0,
    E_OUT_OF_MEMORY = 0x100,
    E_INSTANCE_NOT_INITIALIZED = 0x101,
    E_INSUFFICIENT_MEM = 0x102,
    E_INVALID_PARAMETER = 0x103,
    // ...
    E_ACL_MAP_MEM_FAILED = ACL_BASE_ERROR + 5,
    E_ACL_UNMAP_MEM_FAILED = ACL_BASE_ERROR + 6,
};

class HbmFastAlloc {
public:
    bool init(int32_t device_id, size_t vr_mem_size, size_t ph_mem_size,
              size_t ph_page_size, size_t initial_free_pages);
    void deinit();
    void *alloc(size_t req_size);
    bool free(void *ptr);
    void free_all();

    size_t get_last_defrag_elem_size() { return m_last_defrag_elem_size; }
    static void set_log_level(int lvl);
    static int get_log_level();

private:
    bool try_defrag();
    bool handle_defrag(size_t size, size_t &alloc_offset, size_t &alloc_size);

    AclVirtualMemory *mp_avm { nullptr };
    FlexAlloc        *mp_fa  { nullptr };
    std::mutex        m_alloc_map_lock;
    AllocMap          m_alloc_map;           // ptr → (offset, size)
    size_t            m_last_defrag_elem_size { 0 };
    size_t            m_defrag_ctr { 0 };
    size_t            m_defrag_failed { 0 };
};

alloc(size)
  │
  ├─ 1. mp_fa->alloc(size, offset, alloc_size)
  │   ├─ 成功 → 返回对象地址
  │   └─ 失败且为 FRAGMENTATION → 进入 defrag 流程
  │
  ├─ 2. handle_defrag(size, offset, alloc_size)
  │   ├─ try_defrag()
  │   │   ├─ 获取所有空闲区间
  │   │   ├─ 调用 mp_avm->defrag() 重新映射物理页
  │   │   └─ 将新区间插回 FlexAlloc
  │   └─ 再次尝试 mp_fa->alloc()
  │
  └─ 3. 记录到 m_alloc_map，返回地址

bool HbmFastAlloc::free(void *ptr)
{
    std::lock_guard<std::mutex> lock(m_alloc_map_lock);
    auto iter = m_alloc_map.find(static_cast<uint8_t*>(ptr));
    if (iter == m_alloc_map.end()) return false;

    // 通过 FlexAlloc 释放
    mp_fa->free(iter->second.first, iter->second.second);
    m_alloc_map.erase(iter);
    return true;
}

enum HfaLogLevel {
    HFA_LOG_DEBUG = 0,
    HFA_LOG_INFO = 1,
    HFA_LOG_WARNING = 2,
    HFA_LOG_ERROR = 3
};

#define DEBUG_PRINT(...)   HFA_LOG_PRINT_IF(HFA_LOG_DEBUG, stdout, __VA_ARGS__)
#define INFO_PRINT(...)    HFA_LOG_PRINT_IF(HFA_LOG_INFO, stdout, __VA_ARGS__)
#define WARNING_PRINT(...) HFA_LOG_PRINT_IF(HFA_LOG_WARNING, stdout, __VA_ARGS__)
#define ERROR_PRINT(...)   HFA_LOG_PRINT_IF(HFA_LOG_ERROR, stderr, __VA_ARGS__)

PYBIND11_MODULE(TORCH_EXTENSION_NAME, m) {
    m.def("fused_deep_moe", &FusedDeepMoeImplAutograd);
    m.def("get_dispatch_layout", &GetDispatchLayoutImplAutograd);
    m.def("moe_dispatch_prefill", &MoeDispatchPrefillImplAutograd);
    m.def("moe_combine_prefill", &MoeCombinePrefillImplAutograd);
}

PYBIND11_MODULE(TORCH_EXTENSION_NAME, m) {
    m.def("fused_deep_moe", &FusedDeepMoeImplAutograd);
    m.def("all2_all_detour", &all2_all_detour_impl_autograd);
    m.def("reduce_scatter_detour", &reduce_scatter_detour_impl_autograd);
    m.def("cam_get_comm", &cam_get_comm);
    m.def("cam_free_comm", &cam_free_comm);
    m.def("cam_get_rank_size", &cam_get_rank_size);
    m.def("cam_get_and_increase_magic", &cam_get_and_increase_magic);
    m.def("cam_get_magic", &cam_get_magic);
    m.def("a2e", &A2eImplAutograd);
    m.def("e2a", &E2aImplAutograd);

    // ZB Fused Deep MOE Buffer 类
    pybind11::class_<fused_deep_moe::Buffer>(m, "FusedDeepMoeBuffer")
        .def(pybind11::init<>())
        .def("init", &fused_deep_moe::Buffer::init)
        .def("zb_fused_deep_moe", &fused_deep_moe::Buffer::zb_fused_deep_moe)
        .def("is_initialized", &fused_deep_moe::Buffer::is_initialized)
        .def("get_ext_info", &fused_deep_moe::Buffer::get_ext_info)
        .def("get_shmem_workspace", &fused_deep_moe::Buffer::get_shmem_workspace);
}

namespace fused_deep_moe {
class Buffer {
    void init(int rank, int num_ranks, uint64_t memsize, const std::string &ip_port);
    std::vector<at::Tensor> zb_fused_deep_moe(
        const at::Tensor &x,
        const at::Tensor &expert_ids,
        const TensorVector &gmm1_weight,
        // ... 完整参数列表
    );
    bool is_initialized() const;
    int64_t get_ext_info() const;
    int64_t get_shmem_workspace() const;
};
}

TORCH_LIBRARY(umdk_cam_op_lib, m) {
    m.def("fused_deep_moe(...) -> Tensor[]");
    m.def("all2_all_detour(Tensor sendData, Tensor commRankIds, Tensor commArgs, int commId) -> Tensor");
    m.def("reduce_scatter_detour(Tensor sendData, Tensor commRankIds, Tensor commArgs, int commId, int op) -> Tensor");
    m.def("cam_get_comm(int comm_id, int rank, int group_size, str server_ip_port) -> Tensor");
    m.def("cam_free_comm(int comm_id) -> Tensor");
    m.def("a2e(...) -> Tensor[]");
    m.def("e2a(...) -> Tensor");
}

operator_registry.json
├── _comment: 元数据说明
├── soc_versions: 代际 → 算子目录名列表
│   └── ascend910_93: [13 个算子]
└── operator_meta: 算子元数据
    ├── requires_shmem: 是否需要 SHMEM
    ├── family: 家族（用于互斥）
    └── variant: 变体（base/w4a8/fwk）

fused_deep_moe (family=fused_deep_moe, variant=base)
fused_deep_moe_w4a8 (family=fused_deep_moe, variant=w4a8)
  └── 互斥：共享 fused_deep_moe.* 文件名

fused_deep_moe_fwk (family=fused_deep_moe, variant=fwk)
  └── 独立：fused_deep_moe_fwk.* 文件名，可与 base/w4a8 共存

if quant:
    # -q 选择 w4a8，移除 base
    candidates = [o for o in candidates if o != BASE]
    if W4A8 not in candidates:
        candidates.append(W4A8)
else:
    # 默认选择 base，移除 w4a8
    if has_base and has_w4a8:
        candidates = [o for o in candidates if o != W4A8]

build.sh
  │
  ├─ CAM_USE_W4A8=1 → --quant
  ├─ CAM_OP_SELECT="a2e;e2a"  --ops
  └─ SHMEM_HOME_PATH → --shmem 1/0
      │
      └─ select_ops.py
          │
          ├─ 1. 确定候选集
          ├─ 2. 应用互斥规则
          ├─ 3. SHMEM 过滤
          └─ 4. 输出最终列表

master (5 个算子)                          cam_feature (13 个算子)
─────────────────                          ──────────────────────
dispatch_layout                    →        (移除，替换为 ZB 版本)
fused_deep_moe                     →        fused_deep_moe (保留)
moe_combine_normal                 →        moe_combine_normal_zb (SHMEM 化)
moe_dispatch_normal                →        moe_dispatch_normal_zb (SHMEM 化)
notify_dispatch                    →        moe_notify_dispatch_zb (SHMEM 化)
                                       +    moe_combine_lowlatency_zb (新增)
                                       +    moe_dispatch_lowlatency_zb (新增)
                                       +    moe_dispatch_layout_zb (新增)
                                       +    fused_deep_moe_w4a8 (新增量化变体)
                                       +    fused_deep_moe_fwk (新增 FWK 变体)
                                       +    a2e (新增)
                                       +    e2a (新增)
                                       +    all_to_all_detour (新增)
                                       +    reduce_scatter_detour (新增)

共享内存窗口布局 (HBM)
├── [0, 4MB)                    ← COMBINE_STATE_WIN_OFFSET
│   └── combine 算子 flag 区域
├── [204MB, ...)                 ← NOTIFY_DISPATCH_WIN_OFFSET
│   └── notify-dispatch 算子 flag 区域
├── [IPC_CHUNK_FLAG, ...)        ← IPC Chunk 标志区域
└── [peerMems[rank], ...)        ← 每个 rank 的 flag 区域
    ├── Memory A: 卡内同步 flag
    └── Memory B: 卡间同步 flag