mem-cuda:统一存储面

Author: peng li

.cursorrules

@@ -0,0 +1,20 @@
+## agent 规则
++ This is the only AGENTS.md, there are no recursive AGENTS.md
++ When you are working on a bug, first create a standalone file that reproduces the bug and verify it fails in the expected way. Use this to test if your changes work. Once the change is passing, find an appropriate test file to add the test to and make sure to follow local conventions on the test file.
++ Always respond in 中文,不要回答重复的内容（如我提问中的代码）
+
+## deepx的架构
+
+项目分为3部分
+1. 前端。python库的接口风格参考pytorch
+2. 编译，调度器，待设计
+3. 执行器，使用c++,cuda,metal,omp simd等,实现不同executor的算子
+
+# 关于deepx的细节概念
++ deepx.Tensor仅仅就是一个tensor，不像pytorch的tensor，一个tensor其实包含了自身和梯度2个tensor的数据
+
+
+贴近pytorch的接口风格，不要增加任何注释，我会手动添加注释
+
+关于doc目录
+采用Sphinx构建,使用reStructuredText格式

Agents.md

@@ -3,9 +3,11 @@
 本目录用于设计/实现单机多进程的 GPU Tensor 统一存储面（CUDA IPC），并通过 Redis 做 name → IPC handle 的集中注册与控制。
 
 ## 目标
-- 单机内多进程共享**可命名**Tensor（同名即同一块 GPU 内存）。
-- 通过 Redis 维护 name、shape、dtype、device、IPC handle 等元信息。
-- 通过 Redis List 接收创建/获取/删除指令，实现统一的控制面。
+- 管理单机内多进程共享的堆Tensor
+  + 堆tensor不会随着计算完成而被回收
+  + 而栈tensor则是计算过程的中间变量，可以被立即回收
+- 通过 Redis 维护 name、shape、dtype、device、IPC handle 等元信息，供mem-cuda进程、计算进程访问。
+- 通过 Redis List 接收创建/获取/删除指令，实现统一的控制面。并提供redis mem api以及example
 
 ## 设计概述
 ### 1) Redis 元数据（KV/Hash）
@@ -18,7 +20,7 @@
 - `bytes`: int
 - `ipc_handle`: binary
 - `refcount`: int
-
+无需设计tensor owner
 
 ### 2) Redis 指令队列（List）
 控制通道 list key: `tensor_lifecycle`。
@@ -38,64 +40,23 @@
 - 跨 stream 写读需要显式同步（事件/流同步策略）
 
 ## 显存池方案
-你的需求是：**参考 PyTorch 的显存池管理**。这里给出可落地路线：
 
-### 方案 A：接入成熟开源显存池（推荐）
 - **RMM (RAPIDS Memory Manager)**
   - 优点：成熟、支持 pool/async allocator、统计完善
   - 适合：对稳定性与可观察性要求高的生产环境
-- **CUB caching allocator**
-  - 优点：性能好、实现简单
-  - 适合：希望直接嵌入 CUDA 代码路径
-
-> 选择建议：优先 RMM；想保持最小依赖可用 CUB。
-
-### 方案 B：自研简化版显存池（AI 方案）
-如果不引入外部依赖，可先实现一个简化版池：
-- 维护按 size 分桶的 free-list（如 1MB、2MB、4MB…）
-- 分配时优先复用空闲块，不足时 `cudaMalloc` 新块
-- 回收时挂回 free-list，不立刻 `cudaFree`
-- 支持 `recordStream` / `event` 延迟回收，避免跨流释放风险
-
-**建议先实现 MVP**：
-1) 单 GPU
-2) 只支持 `create/get/delete`
-3) dtype 限定 f32
-4) 单进程先跑通，再放开多进程 + IPC
 
-## 安全与一致性
-- Redis 写入与 refcount 需要原子操作（Lua 脚本/事务）
-- 崩溃恢复：定期清理 owner_pid 不存在的条目
-- IPC handle 需与 device id 配对，否则会映射失败
+其他op计算进程可以使用CUB。
 
 ## 目录结构（具体方案）
 ```
 mem-cuda/
   README.md
   doc/
-    design.md                # 细化设计文档与协议约束
-    redis-schema.md          # Redis KV/Hash/List 结构定义
-    ipc.md                   # CUDA IPC 约束、时序与同步策略
-    allocator.md             # 显存池方案与接口
   src/
-    registry/                # Redis 元数据与命令处理
-      redis_client.h
-      redis_client.cpp
-      registry.h
-      registry.cpp
-      lua_scripts/            # 原子脚本
-        create_or_get.lua
-        ref_inc.lua
-        ref_dec.lua
-        gc_sweep.lua
     ipc/                     # CUDA IPC 封装
       ipc.h
       ipc.cpp
       ipc_guard.h             # 设备一致性与错误处理
-    allocator/               # 显存池实现或适配层
-      allocator.h
-      cuda_pool.cpp
-      rmm_adapter.cpp         # 可选
     runtime/                 # 运行时控制（指令/同步）
       lifecycle.h
       lifecycle.cpp
@@ -105,41 +66,30 @@ mem-cuda/
       status/json/logging
   test/
     ipc_demo.cpp
-    registry_demo.cpp
     lifecycle_demo.cpp
-  tools/
-    memcuda_ctl.cpp           # CLI 工具（create/get/delete/list）
 ```
 
 模块职责：
-- `registry/`: Redis 协议、Lua 原子操作、Hash 读写。
 - `ipc/`: CUDA IPC handle 导出/打开/关闭封装。
-- `allocator/`: 统一分配接口；可切换 RMM/自研。
 - `runtime/`: 指令消费/路由与跨 stream 同步策略。
 - `common/`: 状态码、JSON 解析、日志等公共工具聚合。
 
 ## 后续工作清单（分阶段）
 - [ ] 阶段 0：确定目录与接口（完成本 README 细化）
-- [ ] 阶段 1：实现 `registry/` + Redis Lua 原子脚本
-- [ ] 阶段 2：实现 `ipc/` + `allocator/` 的最小实现（f32, 单 GPU）
-- [ ] 阶段 3：实现 `lifecycle/` worker 与 `tools/` CLI
-- [ ] 阶段 4：补齐 `sync/` 策略与崩溃恢复/GC
+- [ ] 阶段 1：实现 `lifecycle/`
+- [ ] 阶段 2：实现 `ipc/`  的最小实现（f32, 单 GPU）
+- [ ] 阶段 3：补齐 `sync/` 策略与崩溃恢复/GC
 
 ## 构建依赖与示例
 
 - 必要系统依赖：CUDA Toolkit (兼容 CMake `CUDAToolkit`), `cmake` >= 3.18, `make`。
-- Redis C++ 客户端：必须安装 `redis++`（redis-plus-plus）及其依赖 `hiredis`。
-- 可选：RMM 库（若启用对应 adapter）。
+- Redis C++ 客户端：必须安装 `redis++`（redis-plus-plus）
+- RMM 库
 
 示例构建命令（在 `executor/mem-cuda` 目录下）：
 
 ```bash
 mkdir -p build && cd build
-cmake .. -DCMAKE_BUILD_TYPE=Release -DUSE_RMM=OFF
+cmake .. -DCMAKE_BUILD_TYPE=Release
 make -j$(nproc)
 ```
-
-常用 CMake 选项：
-
-- `-DUSE_RMM=ON|OFF`：启用 RMM 适配（需要额外提供 RMM 的 include/link 设置）。
-

executor/mem-cuda/README.md

@@ -0,0 +1,61 @@
+#include "redis_client.h"
+
+#include <sw/redis++/redis++.h>
+
+namespace memcuda {
+
+RedisClient::RedisClient(const std::string& uri) {
+    auto* r = new sw::redis::Redis(uri);
+    redis_impl_ = static_cast<void*>(r);
+}
+
+RedisClient::~RedisClient() {
+    auto* r = static_cast<sw::redis::Redis*>(redis_impl_);
+    delete r;
+}
+
+bool RedisClient::HSet(const std::string& key, const std::string& field, const std::string& value) {
+    auto* r = static_cast<sw::redis::Redis*>(redis_impl_);
+    return r->hset(key, field, value);
+}
+
+bool RedisClient::HGet(const std::string& key, const std::string& field, std::string& out) const {
+    auto* r = static_cast<sw::redis::Redis*>(redis_impl_);
+    auto val = r->hget(key, field);
+    if (!val) {
+        return false;
+    }
+    out = *val;
+    return true;
+}
+
+std::unordered_map<std::string, std::string> RedisClient::HGetAll(const std::string& key) const {
+    auto* r = static_cast<sw::redis::Redis*>(redis_impl_);
+    std::unordered_map<std::string, std::string> res;
+    r->hgetall(key, std::inserter(res, res.begin()));
+    return res;
+}
+
+long long RedisClient::LPush(const std::string& key, const std::string& value) {
+    auto* r = static_cast<sw::redis::Redis*>(redis_impl_);
+    return r->lpush(key, value);
+}
+
+bool RedisClient::BRPop(const std::string& key, int timeout_seconds, std::string& out) const {
+    auto* r = static_cast<sw::redis::Redis*>(redis_impl_);
+    auto item = r->brpop(key, std::chrono::seconds(timeout_seconds));
+    if (!item) {
+        return false;
+    }
+    out = item->second;
+    return true;
+}
+
+std::string RedisClient::Eval(const std::string& script,
+                              const std::vector<std::string>& keys,
+                              const std::vector<std::string>& args) const {
+    auto* r = static_cast<sw::redis::Redis*>(redis_impl_);
+    return r->eval<std::string>(script, keys.begin(), keys.end(), args.begin(), args.end());
+}
+
+}

executor/mem-cuda/src/registry/redis_client.cpp

@@ -0,0 +1,29 @@
+#pragma once
+
+#include <string>
+#include <vector>
+#include <unordered_map>
+
+namespace memcuda {
+
+class RedisClient {
+public:
+    explicit RedisClient(const std::string& uri);
+    ~RedisClient();
+
+    bool HSet(const std::string& key, const std::string& field, const std::string& value);
+    bool HGet(const std::string& key, const std::string& field, std::string& out) const;
+    std::unordered_map<std::string, std::string> HGetAll(const std::string& key) const;
+
+    long long LPush(const std::string& key, const std::string& value);
+    bool BRPop(const std::string& key, int timeout_seconds, std::string& out) const;
+
+    std::string Eval(const std::string& script,
+                     const std::vector<std::string>& keys,
+                     const std::vector<std::string>& args) const;
+
+private:
+    void* redis_impl_;
+};
+
+}

executor/mem-cuda/src/registry/redis_client.h

@@ -0,0 +1,88 @@
+#include "registry.h"
+
+#include <fstream>
+#include <sstream>
+
+namespace memcuda {
+
+Registry::Registry(RedisClient* client, const std::string& lua_dir)
+    : client_(client), lua_dir_(lua_dir) {}
+
+std::string Registry::Key(const std::string& name) const {
+    return "tensor:" + name;
+}
+
+std::string Registry::Script(const std::string& file) const {
+    std::ifstream in(lua_dir_ + "/" + file, std::ios::in | std::ios::binary);
+    std::ostringstream ss;
+    ss << in.rdbuf();
+    return ss.str();
+}
+
+std::string Registry::CreateOrGet(const std::string& name,
+                                  const std::string& dtype,
+                                  const std::string& shape,
+                                  long long device,
+                                  long long bytes,
+                                  const std::string& node,
+                                  long long pid,
+                                  long long ctime,
+                                  const std::string& ipc_handle) {
+    std::vector<std::string> keys{Key(name)};
+    std::vector<std::string> args{
+        dtype,
+        shape,
+        std::to_string(device),
+        std::to_string(bytes),
+        node,
+        std::to_string(pid),
+        std::to_string(ctime),
+        ipc_handle
+    };
+    return client_->Eval(Script("create_or_get.lua"), keys, args);
+}
+
+long long Registry::RefInc(const std::string& name) {
+    std::vector<std::string> keys{Key(name)};
+    std::vector<std::string> args;
+    auto res = client_->Eval(Script("ref_inc.lua"), keys, args);
+    return std::stoll(res);
+}
+
+long long Registry::RefDec(const std::string& name) {
+    std::vector<std::string> keys{Key(name)};
+    std::vector<std::string> args;
+    auto res = client_->Eval(Script("ref_dec.lua"), keys, args);
+    return std::stoll(res);
+}
+
+long long Registry::GcSweep(const std::string& node) {
+    std::vector<std::string> keys;
+    std::vector<std::string> args{node};
+    auto res = client_->Eval(Script("gc_sweep.lua"), keys, args);
+    return std::stoll(res);
+}
+
+bool Registry::GetMeta(const std::string& name, TensorMeta& out) const {
+    auto map = client_->HGetAll(Key(name));
+    if (map.empty()) {
+        return false;
+    }
+    out.dtype = map["dtype"];
+    out.shape = map["shape"];
+    out.node = map["node"];
+    out.ipc_handle = map["ipc_handle"];
+    out.state = map["state"];
+    if (map.count("device")) out.device = std::stoll(map["device"]);
+    if (map.count("bytes")) out.bytes = std::stoll(map["bytes"]);
+    if (map.count("refcount")) out.refcount = std::stoll(map["refcount"]);
+    if (map.count("owner_pid")) out.owner_pid = std::stoll(map["owner_pid"]);
+    if (map.count("ctime")) out.ctime = std::stoll(map["ctime"]);
+    return true;
+}
+
+RedisClient* Registry::Client() const {
+    return client_;
+}
+
+}