Ch17: 数据容器——同一个问题的六种回答

// ncnn/src/mat.h 核心结构（简化版）
class Mat {
public:
    void* data;       // 数据指针
    int* refcount;    // 引用计数（多个 Mat 可共享同一块内存）

    int dims;          // 维度数：1/2/3/4
    int w, h, d, c;    // 宽、高、深度、通道

    // elempack：每个逻辑位置打包的元素个数
    // ARM NEON 上通常为 1/4/8
    // AVX2 上通常为 1/4/8
    // AVX-512 上通常为 1/4/8/16
    size_t elempack;
    size_t elemsize;   // 每个打包元素的字节数 = elempack * sizeof(T)

    size_t cstep;      // 通道步长
};

// 创建一个 elempack=4 的 Mat
// 逻辑形状：64 个通道，每个通道 56x56
// 物理存储：16 个 "pack4 通道"，每个通道 56x56，每个位置存 4 个 float
ncnn::Mat packed;
packed.create(56, 56, 64 / 4, 4u * 4, 4);
// 参数含义：w=56, h=56, c=16, elemsize=16(4个float), elempack=4

// 访问时，一个"逻辑通道组"的数据连续存放
float* ptr = packed.channel(0); // 指向第 0-3 通道的打包数据
// ptr[0], ptr[1], ptr[2], ptr[3] = 通道 0,1,2,3 在位置(0,0)的值
// ptr[4], ptr[5], ptr[6], ptr[7] = 通道 0,1,2,3 在位置(1,0)的值

ncnn::Mat a(224, 224, 3);  // 创建 Mat，refcount = 1
ncnn::Mat b = a;            // 浅拷贝，refcount = 2，共享内存
// a 和 b 指向同一块数据

// channel_range：零拷贝通道切片
ncnn::Mat first_half = a.channel_range(0, 32);
// first_half 指向 a 的前 32 个通道，不拷贝数据
// 内部只是调整了 data 指针和 c 字段

// 在 ARM NEON 上，fill(0.f) 会使用 vdupq_n_f32 指令
// 一次填充 4 个 float（128-bit）
void Mat::fill(float _v) {
    int size = (int)total();
    float* ptr = (float*)data;
#if __ARM_NEON
    float32x4_t _p = vdupq_n_f32(_v);
    int nn = size >> 2;
    for (int i = 0; i < nn; i++) {
        vst1q_f32(ptr, _p);
        ptr += 4;
    }
#endif
    int remain = size & 3;
    for (int i = 0; i < remain; i++) {
        *ptr++ = _v;
    }
}

// MNN/source/core/TensorUtils.hpp（简化版）
struct InsideDescribe {
    enum MemoryType {
        MEMORY_HOST,    // CPU 内存
        MEMORY_DEVICE,  // 设备内存（GPU 等）
        MEMORY_VIRTUAL  // 虚拟内存（不实际分配，通过 Region 引用其他 Tensor）
    };
    MemoryType memoryType = MEMORY_HOST;

    // 虚拟 Region 列表——零拷贝 Reshape/Transpose 的核心
    struct Region {
        Tensor* origin;        // 数据实际来源
        int32_t offset;        // 在源数据中的偏移
        int32_t size[3];       // 三维尺寸
        int32_t src_stride[3]; // 源数据的步长
        int32_t dst_stride[3]; // 目标数据的步长
    };
    std::vector<Region> regions;

    Usage usage = NORMAL;
    Backend* backend = nullptr;
};

// Transpose [2,3] -> [3,2] 的 Region 描述
Region r;
r.origin = src_tensor;
r.offset = 0;
r.size[0] = 1;
r.size[1] = 3;            // 目标的第一维
r.size[2] = 2;            // 目标的第二维
r.src_stride[0] = 6;
r.src_stride[1] = 1;      // 源中"列"方向步长为 1
r.src_stride[2] = 3;      // 源中"行"方向步长为 3
r.dst_stride[0] = 6;
r.dst_stride[1] = 2;      // 目标中"行"方向步长为 2
r.dst_stride[2] = 1;      // 目标中"列"方向步长为 1

// onnxruntime/core/framework/ort_value.h（简化版）
class OrtValue {
    void* data_;      // 指向实际数据的 void 指针
    MLDataType type_; // 数据类型信息
    // 通过 type_ 来判断 data_ 实际指向的是 Tensor 还是其他类型
};

// onnxruntime/core/framework/tensor.h（简化版）
class Tensor {
    MLDataType dtype_;           // 数据类型
    TensorShape shape_;          // 形状信息
    void* p_data_;               // 数据指针（不拥有）
    OrtMemoryInfo memory_info_;  // 内存位置描述
    ptrdiff_t byte_offset_;      // 在 buffer 中的偏移
    int64_t* strides_;           // 步长数组

    // 可选的 deleter 来释放数据
    BufferDeleter buffer_deleter_;
};

struct OrtMemoryInfo {
    OrtAllocatorType alloc_type; // 分配器类型
    OrtMemType mem_type;         // 内存类型
    OrtDevice device;            // 设备信息
};

struct OrtDevice {
    DeviceType device_type;   // CPU / CUDA / OpenVINO / DML / ...
    MemoryType memory_type;   // Default / CUDA_PINNED / HBM / ...
    DeviceId device_id;       // 设备编号（多 GPU 场景）
};

class TensorShape {
    static constexpr size_t kInlineSize = 5;
    int64_t inline_dims_[kInlineSize]; // 栈上存储
    int64_t* p_dims_;   // 超过 5 维时指向堆内存
    size_t n_dims_;

public:
    TensorShape(std::initializer_list<int64_t> dims) {
        n_dims_ = dims.size();
        if (n_dims_ <= kInlineSize) {
            p_dims_ = inline_dims_;  // 直接用栈上数组
            std::copy(dims.begin(), dims.end(), inline_dims_);
        } else {
            p_dims_ = new int64_t[n_dims_]; // 超过 5 维才堆分配
            std::copy(dims.begin(), dims.end(), p_dims_);
        }
    }
};

// TNN/source/tnn/core/blob.h（简化版）
struct BlobDesc {
    DeviceType device_type;  // CPU / ARM / OPENCL / METAL / CUDA / ...
    DataType data_type;      // FLOAT / HALF / INT8 / INT32 / ...
    DataFormat data_format;  // NCHW / NHWC / NC4HW4 / NC8HW8 / ...
    DimsVector dims;         // 形状：{N, C, H, W}
    std::string name;        // Blob 名称（对应模型中的张量名）
};

enum DataFormat {
    DATA_FORMAT_NCHW     = 0,  // 标准 NCHW
    DATA_FORMAT_NHWC     = 1,  // TensorFlow 风格
    DATA_FORMAT_NC4HW4   = 2,  // 4 通道打包（ARM/GPU 友好）
    DATA_FORMAT_NC8HW8   = 3,  // 8 通道打包（AVX2 友好）
    DATA_FORMAT_NCDHW    = 4,  // 5 维（3D 卷积）
    DATA_FORMAT_NHC4W4   = 5,  // Metal 专用布局
    DATA_FORMAT_NC16HW16 = 6,  // AVX-512 友好
};

struct BlobHandle {
    void* base;            // 数据基地址
    uint64_t bytes_offset; // 在基地址上的偏移量
};

// TNN/source/tnn/core/blob_manager.h（简化版）
class BlobManager {
public:
    // 根据计算图分析，一次性为所有中间 Blob 分配内存
    Status Init(NetworkConfig& config,
                NetStructure* net_structure,
                InputShapesMap inputs_shape_map,
                DataType input_data_type);

    // 获取所有输入/输出 Blob
    Status GetAllInputBlobs(BlobMap& blobs);
    Status GetAllOutputBlobs(BlobMap& blobs);

private:
    // 内存池：预分配大块内存，按偏移分配给各 Blob
    AbstractDevice* device_;
    // key = blob 名称, value = Blob 指针
    std::map<std::string, Blob*> input_blobs_;
    std::map<std::string, Blob*> output_blobs_;

    // 通过分析张量生命周期，复用不重叠的内存区域
    MemoryAssignStrategy strategy_;
};

class Blob {
public:
    Blob(BlobDesc desc) : desc_(desc) {}
    Blob(BlobDesc desc, BlobHandle handle)
        : desc_(desc), handle_(handle) {}

    BlobDesc& GetBlobDesc() { return desc_; }
    BlobHandle GetHandle() { return handle_; }
    void SetHandle(BlobHandle handle) { handle_ = handle; }

private:
    BlobDesc desc_;    // 描述信息（形状、格式、设备类型）
    BlobHandle handle_; // 数据指针（基地址 + 偏移）
};

// paddle-lite/lite/core/tensor.h（简化版）
class TensorLite {
    // 三维类型标签——直接告诉你这个张量属于哪个硬件
    TargetType target_;       // Host / X86 / ARM / OpenCL / Metal / FPGA / ...
    PrecisionType precision_; // Float / Int8 / Int16 / Int32 / Int64 / FP16 / ...
    DataLayoutType layout_;   // NCHW / NHWC / NC4HW4 / Any / ...

    DDimLite dims_;           // 形状
    Buffer buffer_;           // 底层数据缓冲区
    LoD lod_;                 // Level of Detail（变长序列信息）

    size_t memory_size_{0};   // 已分配的内存大小
    size_t offset_{0};        // 数据偏移
};

// 类型标签的使用示例
void SomeOp::Run() {
    auto& input = scope.FindVar("Input")->Get<TensorLite>();

    // 根据 target 选择实现
    if (input.target() == TARGET(kARM)) {
        // ARM 实现
    } else if (input.target() == TARGET(kOpenCL)) {
        // OpenCL 实现
    }

    // 根据 precision 选择计算精度
    if (input.precision() == PRECISION(kFloat)) {
        // float32 计算
    } else if (input.precision() == PRECISION(kInt8)) {
        // int8 量化计算
    }
}

class Buffer {
    void* data_{nullptr};     // 数据指针，初始为 null
    TargetType target_;       // 目标硬件
    size_t space_{0};         // 已分配空间大小

public:
    void* data() const { return data_; }

    void ResetLazy(TargetType target, size_t size) {
        // 如果已有足够空间，不重新分配
        if (space_ >= size && target_ == target) return;
        Free();  // 释放旧内存
        target_ = target;
        space_ = size;
        // 延迟分配：真正的 malloc 在这里发生
        data_ = TargetMalloc(target, size);
    }
};

// TensorLite 的 Resize 不分配内存，只设置形状
void TensorLite::Resize(const DDimLite& dims) {
    dims_ = dims;
    // 注意：没有分配内存！
}

// 实际分配在 mutable_data 时发生
template <typename T>
T* TensorLite::mutable_data() {
    memory_size_ = dims_.production() * sizeof(T);
    buffer_.ResetLazy(target_, memory_size_);
    return static_cast<T*>(buffer_.data());
}

// LoD 示例：存储 3 个不同长度的句子
// 句子1: "我 爱 学习"（3 个词）
// 句子2: "今天 天气 真 好"（4 个词）
// 句子3: "你好"（2 个词）

TensorLite tensor;
tensor.Resize({9, 128}); // 共 9 个词，每个词 128 维特征

// LoD 信息记录每个序列的起止位置
LoD lod = {{0, 3, 7, 9}};
// 句子1: 索引 0~2
// 句子2: 索引 3~6
// 句子3: 索引 7~8
tensor.set_lod(lod);

// mace/core/tensor.h（简化版）
class Tensor {
public:
    // Runtime 指针：多态的关键
    // CpuRuntime / GpuRuntime / HexagonRuntime 等
    Runtime* runtime_;

    // Buffer：底层数据存储
    // CpuBuffer / OpenCLBuffer / OpenCLImage 等
    std::unique_ptr<Buffer> buffer_;

    // 元数据
    std::string name_;
    DataType dtype_;         // DT_FLOAT / DT_HALF / DT_UINT8 / ...
    std::vector<index_t> shape_;
    float scale_;            // 量化 scale
    int32_t zero_point_;     // 量化 zero_point

    // 缓冲区内容类型
    BufferContentType content_type_;
};

// CPU 上的 Tensor 可以直接访问数据
Tensor cpu_tensor;
float* data = cpu_tensor.mutable_data<float>();
// 直接读写 data 指针

// GPU（OpenCL）上的 Tensor 不能直接访问
// 需要先 Map 到 CPU 地址空间
Tensor gpu_tensor; // 底层数据在 GPU 上
gpu_tensor.MapBuffer(
    AllocatorMapType::AMT_READ_WRITE,
    BlockFlag::BF_TRUE  // 阻塞等待 GPU 操作完成
);
float* mapped_data = gpu_tensor.mutable_data<float>();
// 现在可以在 CPU 上读写 mapped_data
// ...操作完成后
gpu_tensor.UnMapBuffer();
// 数据同步回 GPU

enum BufferContentType {
    IN_OUT_CHANNEL = 0,  // 输入/输出通道维度
    IN_OUT_HEIGHT  = 1,  // 输入/输出高度维度
    IN_OUT_WIDTH   = 2,  // 输入/输出宽度维度
    CONV2D_FILTER  = 3,  // 2D 卷积权重
    DW_CONV2D_FILTER = 4, // 深度可分离卷积权重
    WEIGHT_HEIGHT  = 5,  // 权重高度
    WEIGHT_WIDTH   = 6,  // 权重宽度
    ARGUMENT       = 7,  // 通用参数
};

class Buffer {
public:
    virtual ~Buffer() = default;

    // 分配内存
    virtual MaceStatus Allocate(index_t nbytes) = 0;

    // 获取数据指针（CPU 可用）
    virtual void* buffer() = 0;

    // Map/UnMap（GPU 数据映射到 CPU）
    virtual MaceStatus Map(AllocatorMapType map_type,
                           BlockFlag block_flag,
                           void** mapped_ptr) = 0;
    virtual MaceStatus UnMap() = 0;

    // 数据大小
    virtual index_t size() const = 0;

protected:
    DataType data_type_;
};

// CPU 实现
class CpuBuffer : public Buffer {
    void* data_;
    MaceStatus Allocate(index_t nbytes) override {
        data_ = memalign(64, nbytes); // 64 字节对齐
        return MaceStatus::MACE_SUCCESS;
    }
    void* buffer() override { return data_; }
    // Map/UnMap 是空操作
    MaceStatus Map(...) override { *mapped_ptr = data_; return ...; }
    MaceStatus UnMap() override { return ...; }
};

// OpenCL Buffer 实现
class OpenCLBuffer : public Buffer {
    cl_mem cl_buffer_;
    MaceStatus Allocate(index_t nbytes) override {
        cl_buffer_ = clCreateBuffer(context, CL_MEM_READ_WRITE,
                                     nbytes, NULL, &err);
        return ...;
    }
    void* buffer() override { return nullptr; } // GPU 数据不能直接访问
    MaceStatus Map(...) override {
        *mapped_ptr = clEnqueueMapBuffer(queue, cl_buffer_, ...);
        return ...;
    }
};