// c10/core/Storage.h
struct C10_API Storage {
    struct use_byte_size_t {};

    Storage() = default;

    // 从已有的 StorageImpl 构造
    Storage(c10::intrusive_ptr<StorageImpl> ptr)
        : storage_impl_(std::move(ptr)) {}

    // 使用分配器分配内存
    Storage(
        use_byte_size_t,
        const SymInt& size_bytes,
        Allocator* allocator = nullptr,
        bool resizable = false)
        : storage_impl_(c10::make_intrusive<StorageImpl>(
              StorageImpl::use_byte_size_t(),
              size_bytes,
              allocator,
              resizable)) {}

    // 使用预分配的 DataPtr
    Storage(
        use_byte_size_t,
        size_t size_bytes,
        at::DataPtr data_ptr,
        at::Allocator* allocator = nullptr,
        bool resizable = false)
        : storage_impl_(c10::make_intrusive<StorageImpl>(
              StorageImpl::use_byte_size_t(),
              size_bytes,
              std::move(data_ptr),
              allocator,
              resizable)) {}

private:
    c10::intrusive_ptr<StorageImpl> storage_impl_;
};

static Storage create_legacy(at::Device device) {
    auto allocator = GetAllocator(device.type());
    return Storage(c10::make_intrusive<StorageImpl>(
        StorageImpl::use_byte_size_t(),
        0,
        allocator->allocate(0),
        allocator,
        true));  // resizable = true
}

// 获取字节大小
size_t nbytes = storage.nbytes();

// 获取数据指针
const void* data = storage.data();
void* mutable_data = storage.mutable_data();

// 设备信息
Device device = storage.device();
DeviceType type = storage.device_type();

// 引用计数
size_t count = storage.use_count();
bool unique = storage.unique();

// Storage 别名检测
bool is_alias = storage1.is_alias_of(storage2);

// c10/core/StorageImpl.h
struct C10_API StorageImpl : public c10::intrusive_ptr_target {
private:
    DataPtr data_ptr_;                                 // 实际数据指针
    SymInt size_bytes_;                                // 存储大小（字节）
    bool size_bytes_is_heap_allocated_;                // size_bytes_ 是否是堆分配的 SymInt
    bool resizable_;                                   // 是否可调整大小
    bool received_cuda_;                               // 是否从其他进程接收的 CUDA 内存
    bool has_mutable_data_ptr_check_ = false;          // 可变数据指针的检查守卫
    bool throw_on_mutable_data_ptr_ = false;           // 访问可变指针时是否抛异常
    bool throw_on_immutable_data_ptr_ = false;         // 访问不可变指针时是否抛异常
    bool warn_deprecated_on_mutable_data_ptr_ = false; // 访问可变指针时是否发出弃用警告
    Allocator* allocator_;                             // 分配器指针
    impl::PyObjectSlot pyobj_slot_;                    // Python 对象引用
    std::unique_ptr<StorageExtraMeta> extra_meta_;     // 额外元数据
};

// 构造函数 1: 预分配内存
StorageImpl(
    use_byte_size_t,
    SymInt size_bytes,
    at::DataPtr data_ptr,
    at::Allocator* allocator,
    bool resizable)
    : data_ptr_(std::move(data_ptr)),
      size_bytes_(std::move(size_bytes)),
      size_bytes_is_heap_allocated_(size_bytes_.is_heap_allocated()),
      resizable_(resizable),
      received_cuda_(false),
      allocator_(allocator) {
    if (resizable) {
        TORCH_INTERNAL_ASSERT(allocator_, "For resizable storage, allocator must be provided");
    }
}

// 构造函数 2: 由分配器自动分配
StorageImpl(
    use_byte_size_t,
    const SymInt& size_bytes,
    at::Allocator* allocator,
    bool resizable)
    : StorageImpl(
          use_byte_size_t(),
          size_bytes,
          size_bytes.is_heap_allocated()
              ? allocator->allocate(0)                          // 符号化大小时延迟分配
              : allocator->allocate(size_bytes.as_int_unchecked()),  // 具体大小时立即分配
          allocator,
          resizable) {}

// 不可变访问 - 只读
const at::DataPtr& data_ptr() const {
    if (C10_UNLIKELY(throw_on_immutable_data_ptr_)) {
        throw_data_ptr_access_error();
    }
    return data_ptr_;
}

// 可变访问 - 可能触发 CoW 复制
at::DataPtr& mutable_data_ptr() {
    if (C10_UNLIKELY(has_mutable_data_ptr_check_)) {
        if (throw_on_immutable_data_ptr_) throw_data_ptr_access_error();
        if (throw_on_mutable_data_ptr_) throwNullDataPtrError();
        if (warn_deprecated_on_mutable_data_ptr_) warnDeprecatedDataPtr();
        maybe_materialize_cow();  // 关键：触发 CoW 物化
    }
    return data_ptr_;
}

// c10/core/Allocator.h
class C10_API DataPtr {
private:
    c10::detail::UniqueVoidPtr ptr_;  // void* + context + deleter
    Device device_;                    // 设备信息

public:
    DataPtr() : device_(DeviceType::CPU) {}

    DataPtr(void* data, Device device)
        : ptr_(data), device_(device) {}

    // data: 用户看到的数据指针
    // ctx:  传递给删除器的上下文（可以和 data 不同）
    // ctx_deleter: 删除器函数指针
    DataPtr(void* data, void* ctx, DeleterFnPtr ctx_deleter, Device device)
        : ptr_(data, ctx, ctx_deleter), device_(device) {}
};

void* get() const { return ptr_.get(); }           // 获取 data 指针
void* get_context() const { return ptr_.get_context(); } // 获取 context 指针
DeleterFnPtr get_deleter() const { return ptr_.get_deleter(); } // 获取删除器
Device device() const { return device_; }           // 获取设备

struct C10_API InefficientStdFunctionContext {
    void* ptr_{nullptr};
    std::function<void(void*)> deleter_;

    static DataPtr makeDataPtr(
        void* ptr,
        std::function<void(void*)> deleter,
        Device device);
};

// c10/core/Allocator.h
struct C10_API Allocator {
    virtual ~Allocator() = default;

    // 核心分配方法：分配 n 字节，返回 DataPtr
    virtual DataPtr allocate(size_t n) = 0;

    // 克隆一段已分配的内存
    DataPtr clone(const void* data, std::size_t n);

    // 检查 DataPtr 是否有简单上下文
    virtual bool is_simple_data_ptr(const DataPtr& data_ptr) const;

    // 返回原始删除器（如果支持 raw_allocate/raw_deallocate）
    virtual DeleterFnPtr raw_deleter() const { return nullptr; }

    // 原始分配和释放（需要 raw_deleter() 返回非空）
    void* raw_allocate(size_t n);
    void raw_deallocate(void* ptr);

    // 数据复制（纯虚函数）
    virtual void copy_data(void* dest, const void* src, std::size_t count) const = 0;
};

// 注册分配器
C10_API void SetAllocator(DeviceType t, Allocator* alloc, uint8_t priority = 0);

// 获取分配器
C10_API Allocator* GetAllocator(const DeviceType& t);

// 宏便利注册
#define REGISTER_ALLOCATOR(t, f) \
    namespace { static c10::AllocatorRegisterer<t> g_##t##_allocator(f); }

// c10/core/impl/COW.h
namespace c10::impl::cow {

// 创建 CoW 克隆，同时将原 storage 转换为 CoW 模式
c10::intrusive_ptr<StorageImpl> lazy_clone_storage(StorageImpl& storage);

// 检查 storage 是否有简单的 DataPtr
bool has_simple_data_ptr(const c10::StorageImpl& storage);

// 检查 DataPtr 是否处于 CoW 模式
bool is_cow_data_ptr(const c10::DataPtr& data_ptr);

// 物化 CoW storage - 实际执行数据复制
void materialize_cow_storage(StorageImpl& storage);

}

// 检查当前 DataPtr 是否为 CoW 模式
inline bool is_cow() const {
    return c10::impl::cow::is_cow_data_ptr(data_ptr_);
}

// 如果是 CoW，则执行物化
void maybe_materialize_cow() {
    if (is_cow()) {
        impl::cow::materialize_cow_storage(*this);
    }
}

at::DataPtr& mutable_data_ptr() {
    if (C10_UNLIKELY(has_mutable_data_ptr_check_)) {
        // ... 各种检查 ...
        maybe_materialize_cow();
    }
    return data_ptr_;
}

// 每种设备类型可以注册自定义的 StorageImpl 创建函数
using StorageImplCreateHelper = intrusive_ptr<StorageImpl> (*)(
    StorageImpl::use_byte_size_t,
    SymInt size_bytes,
    DataPtr data_ptr,
    Allocator* allocator,
    bool resizable);

void SetStorageImplCreate(DeviceType t, StorageImplCreateHelper fptr);
StorageImplCreateHelper GetStorageImplCreate(DeviceType t);

// 通用创建函数：先查找设备特定的创建器，找不到则使用默认构造
c10::intrusive_ptr<c10::StorageImpl> make_storage_impl(
    c10::StorageImpl::use_byte_size_t use_byte_size,
    c10::SymInt size_bytes,
    c10::DataPtr data_ptr,
    c10::Allocator* allocator,
    bool resizable,
    std::optional<at::Device> device_opt);

import torch

# 1. 创建 Tensor -- 触发分配
t = torch.randn(1000, 1000)  # 1M floats = 4MB

# 2. 创建 View -- 共享 Storage，无新分配
v = t[100:200, :]  # view: offset=100*1000, shape=(100, 1000)

# 3. clone 操作 -- 分配新 Storage，复制数据
c = t.clone()

# 验证
print(t.storage().data_ptr() == v.storage().data_ptr())  # True  -- 共享
print(t.storage().data_ptr() == c.storage().data_ptr())  # False -- 独立