classDiagram
    class Tensor {
        -TensorShape shape_
        -DataType dtype_
        -TensorBuffer* buffer_
        +dims() int
        +flat() Eigen::Tensor
        +matrix() Eigen::Matrix
        +SharesBufferWith(Tensor) bool
    }
    
    class TensorBuffer {
        <<interface>>
        +data() void*
        +size() size_t
        +RefCountIsOne() bool
    }
    
    class TensorShape {
        -gtl::InlinedVector dims_
        +dims() int
        +dim_size(int) int64
        +num_elements() int64
        +AddDim(int64)
    }
    
    class DataType {
        <<enumeration>>
        DT_FLOAT
        DT_DOUBLE
        DT_INT32
        DT_STRING
        DT_RESOURCE
    }
    
    class OpDef {
        +string name
        +repeated ArgDef input_arg
        +repeated ArgDef output_arg
        +repeated AttrDef attr
        +bool is_commutative
        +bool is_stateful
    }
    
    class OpKernel {
        <<abstract>>
        #NodeDef def_
        #DataTypeVector input_types_
        #DataTypeVector output_types_
        +Compute(OpKernelContext*)*
        +IsExpensive() bool
        +name() string
    }
    
    class OpKernelContext {
        +input(int) Tensor
        +allocate_output(int, TensorShape, Tensor**)
        +set_output(int, Tensor)
        +SetStatus(Status)
        +device() Device*
    }
    
    class OpKernelConstruction {
        +GetAttr(string, T*) Status
        +allocate_temp(DataType, TensorShape, Tensor*)
        +device_type() DeviceType
    }
    
    class OpRegistry {
        -map~string, OpRegistrationData~ registry_
        +Register(OpRegistrationData)
        +LookUp(string, OpRegistrationData**) Status
        +Global() OpRegistry*
    }
    
    class Device {
        <<abstract>>
        +Compute(OpKernel*, OpKernelContext*)
        +GetAllocator(AllocatorAttributes) Allocator*
        +Sync() Status
    }
    
    class Allocator {
        <<interface>>
        +AllocateRaw(size_t) void*
        +DeallocateRaw(void*)
        +Name() string
    }
    
    Tensor --> TensorShape
    Tensor --> DataType
    Tensor --> TensorBuffer
    OpKernel --> OpDef
    OpKernel ..> OpKernelContext : uses
    OpKernel ..> OpKernelConstruction : uses
    OpKernelContext --> Tensor
    OpKernelContext --> Device
    OpRegistry --> OpDef
    Device --> Allocator

classDiagram
    class Tensor {
        -TensorShape shape_
        -DataType dtype_
        -TensorBuffer* buffer_
        -size_t buf_offset_
        +Tensor()
        +Tensor(Allocator*, DataType, TensorShape)
        +dtype() DataType
        +shape() TensorShape
        +NumElements() int64
        +TotalBytes() size_t
        +flat~T~() TTypes~T~::Flat
        +matrix~T~() TTypes~T~::Matrix
        +SharesBufferWith(Tensor) bool
        +Slice(int64, int64) Tensor
    }
    
    class TensorShape {
        -InlinedVector~int64, 6~ dims_
        -int64 num_elements_
        +TensorShape()
        +TensorShape(ArraySlice~int64~)
        +dims() int
        +dim_size(int) int64
        +num_elements() int64
        +AddDim(int64)
        +RemoveDim(int)
        +set_dim(int, int64)
        +IsSameSize(TensorShape) bool
        +AsProto(TensorShapeProto*)
    }
    
    class TensorBuffer {
        <<abstract>>
        -std::atomic~int32~ ref_
        #void* data_
        #size_t size_
        +data() void*
        +size() size_t
        +Ref()
        +Unref()
        +RefCountIsOne() bool
        +GetAllocatedBytes() size_t
    }
    
    class BufferBase {
        -void* data_
        -size_t size_
        -Allocator* allocator_
        +data() void*
        +size() size_t
    }
    
    class DataType {
        <<enumeration>>
        DT_INVALID
        DT_FLOAT
        DT_DOUBLE
        DT_INT32
        DT_INT64
        DT_STRING
        DT_RESOURCE
        DT_VARIANT
        ...
    }
    
    Tensor --> TensorShape : 包含
    Tensor --> DataType : 引用
    Tensor --> TensorBuffer : 持有引用
    TensorBuffer <|-- BufferBase : 实现

// tensor.proto
message TensorProto {
  DataType dtype = 1;
  TensorShapeProto tensor_shape = 2;
  
  // 版本号（用于兼容性）
  int32 version_number = 3;
  
  // 原始字节数组（推荐用于大tensor）
  bytes tensor_content = 4;
  
  // 类型特定数组（方便小tensor）
  repeated int32 half_val = 13 [packed = true];   // DT_HALF, DT_BFLOAT16
  repeated float float_val = 5 [packed = true];   // DT_FLOAT
  repeated double double_val = 6 [packed = true]; // DT_DOUBLE
  repeated int32 int_val = 7 [packed = true];     // DT_INT32
  repeated bytes string_val = 8;                  // DT_STRING
  // ...更多类型
}

message TensorShapeProto {
  message Dim {
    int64 size = 1;     // 维度大小，-1表示未知
    string name = 2;    // 可选的维度名称
  }
  repeated Dim dim = 2;
  bool unknown_rank = 3;  // true表示秩未知
}

classDiagram
    class OpDef {
        +string name
        +repeated ArgDef input_arg
        +repeated ArgDef output_arg
        +repeated AttrDef attr
        +repeated string control_output
        +OpDeprecation deprecation
        +string summary
        +string description
        +bool is_commutative
        +bool is_aggregate
        +bool is_stateful
        +bool allows_uninitialized_input
        +bool is_distributed_communication
    }
    
    class ArgDef {
        +string name
        +string description
        +DataType type
        +string type_attr
        +string number_attr
        +string type_list_attr
        +repeated ResourceHandleProto.DtypeAndShape handle_data
        +bool is_ref
        +FullTypeDef experimental_full_type
    }
    
    class AttrDef {
        +string name
        +string type
        +AttrValue default_value
        +string description
        +bool has_minimum
        +int64 minimum
        +AttrValue allowed_values
    }
    
    class OpDeprecation {
        +int32 version
        +string explanation
    }
    
    class OpRegistry {
        -map~string, OpRegistrationData~ registry_
        +Register(OpDefBuilder)
        +LookUp(string, OpRegistrationData**) Status
        +GetRegisteredOps() OpList
        +Global() OpRegistry*
    }
    
    class OpRegistrationData {
        +OpDef op_def
        +OpShapeInferenceFn shape_inference_fn
        +bool is_function_op
    }
    
    OpDef --> ArgDef : 包含多个
    OpDef --> AttrDef : 包含多个
    OpDef --> OpDeprecation : 可选包含
    OpRegistry --> OpRegistrationData : 管理多个
    OpRegistrationData --> OpDef : 包含

// MatMul定义
OpDef {
  name: "MatMul"
  input_arg {
    name: "a"
    type_attr: "T"  // 类型由属性T确定
  }
  input_arg {
    name: "b"
    type_attr: "T"  // 同样的类型T
  }
  output_arg {
    name: "product"
    type_attr: "T"
  }
  attr {
    name: "T"
    type: "type"
    allowed_values { list { type: [DT_FLOAT, DT_DOUBLE] } }
  }
  attr {
    name: "transpose_a"
    type: "bool"
    default_value { b: false }
  }
}

class OpRegistry {
 public:
  // 注册Op定义
  void Register(const OpRegistrationDataFactory& op_data_factory);
  
  // 查找Op定义
  const OpRegistrationData* LookUp(const string& op_type_name) const;
  Status LookUp(const string& op_type_name, 
                const OpRegistrationData** op_reg_data) const;
  
  // 获取所有注册的Op
  void Export(bool include_internal, OpList* ops) const;
  OpList GetRegisteredOps();
  
  // 全局单例
  static OpRegistry* Global();
  
 private:
  // 核心数据结构：op名称 -> 注册数据
  std::unordered_map<string, std::unique_ptr<OpRegistrationData>> registry_;
  
  mutable mutex mu_;  // 保护registry_
  std::function<Status(const Status&, const OpDef&)> watcher_;
};

struct OpRegistrationData {
  OpDef op_def;  // Op元数据定义
  OpShapeInferenceFn shape_inference_fn;  // 形状推断函数
  OpTypeConstructor type_ctor;  // 类型构造函数（实验性）
  bool is_function_op;  // 是否为函数Op
};

// 注册时（启动时自动调用）
REGISTER_OP("MyOp")
    .Input("input: T")
    .Output("output: T")
    .Attr("T: {float, int32}")
    .SetShapeFn(shape_inference::UnchangedShape);

// 查找时（图构建时）
const OpRegistrationData* op_reg_data;
Status s = OpRegistry::Global()->LookUp("MyOp", &op_reg_data);
if (s.ok()) {
  const OpDef& op_def = op_reg_data->op_def;
  // 验证NodeDef与OpDef兼容
}

// op_def.proto
message OpDef {
  string name = 1;
  
  message ArgDef {
    string name = 1;
    string description = 2;
    DataType type = 3;
    string type_attr = 4;
    string number_attr = 5;
    string type_list_attr = 6;
    repeated ResourceHandleProto.DtypeAndShape handle_data = 7;
    bool is_ref = 16;
    FullTypeDef experimental_full_type = 17;
  }
  repeated ArgDef input_arg = 2;
  repeated ArgDef output_arg = 3;
  repeated string control_output = 20;
  
  message AttrDef {
    string name = 1;
    string type = 2;
    AttrValue default_value = 3;
    string description = 4;
    bool has_minimum = 5;
    int64 minimum = 6;
    AttrValue allowed_values = 7;
  }
  repeated AttrDef attr = 4;
  
  OpDeprecation deprecation = 8;
  string summary = 5;
  string description = 6;
  bool is_commutative = 18;
  bool is_aggregate = 16;
  bool is_stateful = 17;
  bool allows_uninitialized_input = 19;
  bool is_distributed_communication = 21;
}

message OpDeprecation {
  int32 version = 1;  // 废弃的GraphDef版本
  string explanation = 2;  // 废弃原因和替代方案
}

message OpList {
  repeated OpDef op = 1;
}

classDiagram
    class AttrValue {
        <<oneof value>>
        +bytes s
        +int64 i
        +float f
        +bool b
        +DataType type
        +TensorShapeProto shape
        +TensorProto tensor
        +ListValue list
        +NameAttrList func
        +string placeholder
    }
    
    class ListValue {
        +repeated bytes s
        +repeated int64 i
        +repeated float f
        +repeated bool b
        +repeated DataType type
        +repeated TensorShapeProto shape
        +repeated TensorProto tensor
        +repeated NameAttrList func
    }
    
    class NameAttrList {
        +string name
        +map~string, AttrValue~ attr
    }
    
    AttrValue --> ListValue : 包含
    AttrValue --> NameAttrList : 包含

// 设置int属性
AttrValue attr_value;
attr_value.set_i(128);

// 设置type属性
attr_value.set_type(DT_FLOAT);

// 设置list(int)属性
auto* list = attr_value.mutable_list();
list->add_i(1);
list->add_i(2);
list->add_i(3);

// 设置shape属性
auto* shape = attr_value.mutable_shape();
shape->add_dim()->set_size(224);
shape->add_dim()->set_size(224);
shape->add_dim()->set_size(3);

classDiagram
    class GraphDef {
        +repeated NodeDef node
        +VersionDef versions
        +FunctionDefLibrary library
        +int32 version
    }
    
    class NodeDef {
        +string name
        +string op
        +repeated string input
        +string device
        +map~string, AttrValue~ attr
        +ExperimentalDebugInfo experimental_debug_info
        +FullTypeDef experimental_type
    }
    
    class VersionDef {
        +int32 producer
        +int32 min_consumer
        +repeated int32 bad_consumers
    }
    
    class FunctionDefLibrary {
        +repeated FunctionDef function
        +repeated GradientDef gradient
        +repeated RegisteredGradientDef registered_gradient
    }
    
    GraphDef --> NodeDef : 包含多个
    GraphDef --> VersionDef : 包含
    GraphDef --> FunctionDefLibrary : 包含
    NodeDef --> AttrValue : 包含多个

/job:<job>/replica:<replica>/task:<task>/device:<device_type>:<device_index>

message VersionDef {
  int32 producer = 1;  // 生成此GraphDef的TensorFlow版本
  int32 min_consumer = 2;  // 可执行此GraphDef的最低TensorFlow版本
  repeated int32 bad_consumers = 3;  // 禁止的版本列表
}

bool IsCompatible(const VersionDef& versions) {
  // 检查producer版本不超过当前版本
  if (versions.producer() > TF_GRAPH_DEF_VERSION) {
    return false;  // 图由更新版本生成
  }
  
  // 检查当前版本满足min_consumer要求
  if (TF_GRAPH_DEF_VERSION < versions.min_consumer()) {
    return false;  // 图要求更新的运行时
  }
  
  // 检查不在bad_consumers列表中
  for (int32 bad : versions.bad_consumers()) {
    if (TF_GRAPH_DEF_VERSION == bad) {
      return false;  // 已知不兼容版本
    }
  }
  
  return true;
}

graph LR
    A[TF 1.0<br/>基础OpDef] --> B[TF 1.12<br/>+Resource类型]
    B --> C[TF 2.0<br/>+函数式编程<br/>+Eager模式]
    C --> D[TF 2.5<br/>+更多数值类型<br/>+FullType系统]
    
    style A fill:#e1f5ff
    style B fill:#fff4e1
    style C fill:#e8f5e1
    style D fill:#ffe1f5

# 保存GraphDef
graph_def = sess.graph.as_graph_def()
with open('model.pb', 'wb') as f:
    f.write(graph_def.SerializeToString())

# 加载GraphDef
with open('model.pb', 'rb') as f:
    graph_def = tf.compat.v1.GraphDef()
    graph_def.ParseFromString(f.read())

class Tensor {
 public:
  // 构造函数
  Tensor();  // 空tensor
  Tensor(DataType type, const TensorShape& shape);  // 指定类型和形状
  Tensor(Allocator* a, DataType type, const TensorShape& shape);  // 指定分配器
  
  // 标量tensor构造（主机内存）
  explicit Tensor(float value);
  explicit Tensor(int32_t value);
  explicit Tensor(int64_t value);
  
  // 拷贝和移动
  Tensor(const Tensor& other);
  Tensor(Tensor&& other);
  Tensor& operator=(const Tensor& other);
  Tensor& operator=(Tensor&& other);
  
  ~Tensor();
  
  // 元数据访问
  DataType dtype() const;
  const TensorShape& shape() const;
  int dims() const;
  int64_t dim_size(int d) const;
  int64_t NumElements() const;
  size_t TotalBytes() const;
  size_t AllocatedBytes() const;
  
  // 数据访问（模板方法）
  template <typename T>
  typename TTypes<T>::Flat flat();  // 1D视图
  
  template <typename T>
  typename TTypes<T>::Matrix matrix();  // 2D视图
  
  template <typename T>
  typename TTypes<T>::Tensor tensor();  // ND视图
  
  template <typename T>
  T* flat_data();  // 原始指针
  
  // 只读数据访问
  template <typename T>
  typename TTypes<T>::ConstFlat flat() const;
  
  // 缓冲区操作
  bool SharesBufferWith(const Tensor& b) const;
  bool IsInitialized() const;
  bool IsAligned() const;
  
  // Slice操作
  Tensor Slice(int64_t start, int64_t limit) const;
  
 private:
  TensorShape shape_;  // 形状
  TensorBuffer* buffer_;  // 数据缓冲区
};

// Tensor::Tensor(Allocator* a, DataType type, const TensorShape& shape)
// 功能：创建指定类型和形状的Tensor，从指定分配器分配内存
// 
Tensor::Tensor(Allocator* a, DataType type, const TensorShape& shape)
    : shape_(shape), buffer_(nullptr) {
  
  set_dtype(type);  // 设置数据类型
  
  // 计算所需字节数
  size_t num_bytes = shape.num_elements() * DataTypeSize(type);
  
  if (num_bytes > 0 || a->ShouldAllocateEmptyTensors()) {
    // 分配TensorBuffer
    buffer_ = a->Allocate<TensorBuffer>(num_bytes, type);
    if (buffer_ != nullptr) {
      buffer_->Ref();  // 初始引用计数为1
    }
  }
}

// flat<T>(): 获取1D Eigen::Tensor视图
// 返回类型：Eigen::TensorMap<Eigen::Tensor<T, 1, ...>>
// 
template <typename T>
typename TTypes<T>::Flat Tensor::flat() {
  // 检查类型匹配
  CHECK_EQ(DataTypeToEnum<T>::value, dtype());
  // 检查已初始化
  CHECK(IsInitialized());
  
  // 返回Eigen::TensorMap，映射到底层内存
  return typename TTypes<T>::Flat(
      buffer_->base<T>(),  // 数据指针
      shape_.num_elements());  // 元素总数
}

// matrix<T>(): 获取2D Eigen::Tensor视图
// 前置条件：dims() == 2
//
template <typename T>
typename TTypes<T>::Matrix Tensor::matrix() {
  CHECK_EQ(DataTypeToEnum<T>::value, dtype());
  CHECK_EQ(dims(), 2);  // 必须是2维
  CHECK(IsInitialized());
  
  return typename TTypes<T>::Matrix(
      buffer_->base<T>(),
      shape_.dim_size(0),  // 行数
      shape_.dim_size(1));  // 列数
}

// Slice(start, limit): 创建子tensor视图
// 功能：返回沿第0维的切片 [start, limit)
// 特点：零拷贝，共享底层缓冲区
//
Tensor Tensor::Slice(int64_t start, int64_t limit) const {
  // 验证参数
  CHECK_GE(dims(), 1);  // 至少1维
  CHECK_GE(start, 0);
  CHECK_LE(limit, dim_size(0));
  CHECK_LE(start, limit);
  
  // 创建新Tensor，共享buffer
  Tensor result(dtype());
  
  // 计算切片形状（第0维缩小）
  TensorShape slice_shape = shape_;
  slice_shape.set_dim(0, limit - start);
  result.shape_ = slice_shape;
  
  // 共享缓冲区，偏移起始地址
  if (buffer_) {
    result.buffer_ = buffer_;
    result.buffer_->Ref();  // 增加引用计数
    
    // 计算字节偏移
    size_t bytes_per_slice = DataTypeSize(dtype());
    for (int d = 1; d < dims(); ++d) {
      bytes_per_slice *= dim_size(d);
    }
    result.buf_offset_ = buf_offset_ + start * bytes_per_slice;
  }
  
  return result;  // 返回切片视图
}

用户代码
  └─> tf.constant(value, dtype, shape)  [Python]
      └─> pywrap_tensorflow.TF_NewTensor()  [C API]
          └─> Tensor::Tensor(a, dtype, shape)  [C++]
              ├─> Allocator::AllocateRaw()  [分配内存]
              ├─> TensorBuffer::Ref()  [初始化引用计数]
              └─> 返回Tensor对象

OpKernel::Compute(ctx)
  └─> const Tensor& input = ctx->input(0)
      └─> OpKernelContext::input(index)
          └─> 返回inputs_[index].tensor
              [已在Executor准备阶段设置]

OpKernel::Compute(ctx)
  └─> Tensor* output = nullptr;
      ctx->allocate_output(0, shape, &output)
      └─> OpKernelContext::allocate_output(index, shape, output)
          ├─> 尝试Forward输入（复用缓冲区）
          │   └─> OpKernel::forward_from_array()
          ├─> 如果无法forward，分配新内存
          │   └─> Allocator::AllocateRaw()
          └─> 设置outputs_[index] = new_tensor

sequenceDiagram
    autonumber
    participant User as 用户代码
    participant PyFE as Python前端
    participant CAPI as C API
    participant Tensor as Tensor类
    participant Alloc as Allocator
    participant Buf as TensorBuffer
    
    User->>PyFE: tf.constant([1,2,3])
    PyFE->>CAPI: TF_NewTensor(data, shape, dtype)
    CAPI->>Tensor: Tensor(allocator, dtype, shape)
    Tensor->>Tensor: 计算内存大小
    Tensor->>Alloc: AllocateRaw(num_bytes)
    Alloc->>Alloc: BFC算法查找/分配内存块
    Alloc-->>Tensor: 返回TensorBuffer*
    Tensor->>Buf: buffer_->Ref()
    Buf->>Buf: ref_count = 1
    Tensor->>CAPI: 拷贝数据到buffer
    CAPI-->>PyFE: 返回Tensor handle
    PyFE-->>User: 返回Tensor对象
    
    Note over User,Buf: 使用阶段
    User->>Tensor: tensor.numpy()
    Tensor->>Buf: 获取数据指针
    Buf-->>Tensor: base<T>()
    Tensor-->>User: 返回NumPy数组（共享内存）
    
    Note over User,Buf: 销毁阶段
    User->>Tensor: del tensor
    Tensor->>Buf: buffer_->Unref()
    Buf->>Buf: ref_count--
    alt ref_count == 0
        Buf->>Alloc: DeallocateRaw(buffer)
        Alloc->>Alloc: 释放内存块
    end

class OpKernel {
 public:
  // 构造函数（在图初始化时调用）
  explicit OpKernel(OpKernelConstruction* context);
  OpKernel(OpKernelConstruction* context, bool is_deferred);
  
  virtual ~OpKernel();
  
  // 核心执行方法（纯虚函数，必须实现）
  virtual void Compute(OpKernelContext* context) = 0;
  
  // 异步Kernel支持
  virtual AsyncOpKernel* AsAsync() { return nullptr; }
  
  // 性能标记
  virtual bool IsExpensive() { return expensive_; }
  
  // 元数据访问
  const NodeDef& def() const { return props_->node_def; }
  const string& name() const { return props_->node_def.name(); }
  const string& type_string() const { return props_->node_def.op(); }
  const string& requested_device() const { 
    return props_->node_def.device(); 
  }
  
  // 输入输出信息
  int num_inputs() const { return props_->input_types.size(); }
  DataType input_type(int i) const { return props_->input_types[i]; }
  int num_outputs() const { return props_->output_types.size(); }
  DataType output_type(int o) const { return props_->output_types[o]; }
  
 protected:
  bool expensive_;  // 是否为昂贵操作
  
 private:
  std::shared_ptr<const NodeProperties> props_;  // 节点属性
  MemoryTypeVector input_memory_types_;  // 输入内存类型（主机/设备）
  MemoryTypeVector output_memory_types_;  // 输出内存类型
};

class OpKernelConstruction {
 public:
  // 属性访问
  template <typename T>
  Status GetAttr(StringPiece attr_name, T* value) const;
  
  // 设备信息
  DeviceType device_type() const { return device_type_; }
  
  // 临时内存分配
  Status allocate_temp(DataType type, const TensorShape& shape,
                       Tensor* out_temp);
  
  // 设置错误状态
  void SetStatus(const Status& status);
  Status status() const { return *status_; }
  
 private:
  const DeviceType device_type_;
  Allocator* allocator_;
  const FunctionLibraryRuntime* flib_;
  const std::shared_ptr<const NodeProperties> props_;
  Status* status_;
};

class OpKernelContext {
 public:
  // 输入访问
  int num_inputs() const { return params_->inputs->size(); }
  const Tensor& input(int index) const { return (*params_->inputs)[index]; }
  
  // 输出分配
  Status allocate_output(int index, const TensorShape& shape,
                         Tensor** output);
  Status set_output(int index, const Tensor& tensor);
  Tensor* mutable_output(int index);
  
  // 临时内存
  Status allocate_temp(DataType type, const TensorShape& shape,
                       Tensor* out_temp, AllocatorAttributes attr = {});
  
  // 设备访问
  Device* device() const { return params_->device; }
  Allocator* get_allocator(AllocatorAttributes attr);
  
  // 状态管理
  void SetStatus(const Status& status);
  Status status() const { return status_; }
  
  // 函数库（用于调用其他操作）
  FunctionLibraryRuntime* function_library() const { 
    return params_->function_library; 
  }
  
  // 取消管理
  CancellationManager* cancellation_manager() const {
    return params_->cancellation_manager;
  }
  
 private:
  const Params* params_;  // 外部传入的参数
  gtl::InlinedVector<TensorValue, 4> outputs_;  // 输出tensors
  Status status_;  // 执行状态
};

// 注册OpDef
REGISTER_OP("Add")
    .Input("x: T")
    .Input("y: T")
    .Output("z: T")
    .Attr("T: {float, int32, int64}")
    .SetIsCommutative()
    .SetShapeFn(shape_inference::UnchangedShape);

// CPU Kernel实现
template <typename T>
class AddOp : public OpKernel {
 public:
  explicit AddOp(OpKernelConstruction* ctx) : OpKernel(ctx) {}
  
  void Compute(OpKernelContext* ctx) override {
    // 1. 获取输入
    const Tensor& x_tensor = ctx->input(0);
    const Tensor& y_tensor = ctx->input(1);
    
    // 2. 验证形状
    OP_REQUIRES(ctx, x_tensor.shape() == y_tensor.shape(),
                errors::InvalidArgument(
                    "x and y must have the same shape. ",
                    "x shape: ", x_tensor.shape().DebugString(),
                    " y shape: ", y_tensor.shape().DebugString()));
    
    // 3. 分配输出
    Tensor* z_tensor = nullptr;
    OP_REQUIRES_OK(ctx, 
        ctx->allocate_output(0, x_tensor.shape(), &z_tensor));
    
    // 4. 执行计算
    auto x = x_tensor.flat<T>();
    auto y = y_tensor.flat<T>();
    auto z = z_tensor->flat<T>();
    
    // 使用Eigen并行执行
    const Eigen::ThreadPoolDevice& d = 
        ctx->eigen_device<Eigen::ThreadPoolDevice>();
    z.device(d) = x + y;
    
    // 输出已设置，无需return
  }
};

// 注册Kernel（针对不同类型）
REGISTER_KERNEL_BUILDER(
    Name("Add").Device(DEVICE_CPU).TypeConstraint<float>("T"),
    AddOp<float>);
REGISTER_KERNEL_BUILDER(
    Name("Add").Device(DEVICE_CPU).TypeConstraint<int32>("T"),
    AddOp<int32>);

class MatMulOp : public OpKernel {
 public:
  explicit MatMulOp(OpKernelConstruction* ctx) : OpKernel(ctx) {
    // 构造时读取并缓存属性
    OP_REQUIRES_OK(ctx, ctx->GetAttr("transpose_a", &transpose_a_));
    OP_REQUIRES_OK(ctx, ctx->GetAttr("transpose_b", &transpose_b_));
  }
  
  void Compute(OpKernelContext* ctx) override {
    // 1. 获取输入矩阵
    const Tensor& a = ctx->input(0);
    const Tensor& b = ctx->input(1);
    
    // 2. 验证输入是矩阵
    OP_REQUIRES(ctx, a.dims() == 2,
                errors::InvalidArgument("a must be a matrix"));
    OP_REQUIRES(ctx, b.dims() == 2,
                errors::InvalidArgument("b must be a matrix"));
    
    // 3. 获取维度
    const int m = transpose_a_ ? a.dim_size(1) : a.dim_size(0);
    const int k_a = transpose_a_ ? a.dim_size(0) : a.dim_size(1);
    const int k_b = transpose_b_ ? b.dim_size(1) : b.dim_size(0);
    const int n = transpose_b_ ? b.dim_size(0) : b.dim_size(1);
    
    // 4. 验证内积维度匹配
    OP_REQUIRES(ctx, k_a == k_b,
                errors::InvalidArgument(
                    "Matrix size-incompatible: In[0]: ", a.shape().DebugString(),
                    ", In[1]: ", b.shape().DebugString()));
    
    // 5. 分配输出
    Tensor* output = nullptr;
    OP_REQUIRES_OK(ctx, ctx->allocate_output(0, TensorShape({m, n}), &output));
    
    // 6. 处理空矩阵
    if (output->NumElements() == 0) {
      return;
    }
    
    // 7. 调用BLAS库执行矩阵乘法
    auto a_matrix = a.matrix<float>();
    auto b_matrix = b.matrix<float>();
    auto output_matrix = output->matrix<float>();
    
    LaunchMatMul<float>::launch(
        ctx, a_matrix, b_matrix, transpose_a_, transpose_b_, output_matrix);
  }
  
 private:
  bool transpose_a_;
  bool transpose_b_;
};

// 注册GPU Kernel（如果支持GPU）
#if GOOGLE_CUDA
REGISTER_KERNEL_BUILDER(
    Name("MatMul").Device(DEVICE_GPU).TypeConstraint<float>("T"),
    MatMulOp<GPUDevice, float>);
#endif

DirectSession::Run()
  └─> GetOrCreateExecutors()
      └─> CreateExecutors()
          └─> Graph::ToGraphDef()
          └─> Executor::NewLocalExecutor(graph)
              └─> ExecutorImpl::Initialize()
                  └─> 遍历每个节点
                      └─> CreateNonCachedKernel(node)
                          ├─> FindKernelDef(device, node, &kernel_def)
                          │   └─> GlobalKernelRegistry()->FindKernel()
                          ├─> CreateOpKernel(device, kernel_def, &kernel)
                          │   ├─> OpKernelConstruction ctx(...)
                          │   └─> kernel_def->factory->Create(&ctx)
                          │       [调用注册的工厂函数]
                          │       └─> new MatMulOp(ctx)
                          │           └─> MatMulOp::MatMulOp(ctx)
                          │               [读取并缓存属性]
                          └─> 缓存kernel到NodeItem

DirectSession::Run(feeds, fetches)
  └─> RunInternal(executors_and_keys)
      └─> Executor::RunAsync(args)
          └─> ExecutorState::RunAsync()
              ├─> 初始化ready队列
              └─> 循环处理ready节点
                  └─> Process(node_item)
                      ├─> 收集输入tensors
                      ├─> 创建OpKernelContext
                      │   └─> OpKernelContext ctx(&params)
                      ├─> Device::Compute(kernel, &ctx)
                      │   └─> kernel->Compute(&ctx)  [虚函数调用]
                      │       [具体Kernel实现]
                      │       └─> MatMulOp::Compute(&ctx)
                      │           ├─> ctx->input(0)  [获取输入]
                      │           ├─> ctx->allocate_output(0, shape, &out)
                      │           ├─> 执行矩阵乘法计算
                      │           └─> return [输出已设置]
                      ├─> 检查ctx->status()
                      └─> 将输出传播给后继节点

sequenceDiagram
    autonumber
    participant Exec as Executor
    participant Sched as Scheduler
    participant Device as Device
    participant Kernel as OpKernel
    participant Ctx as OpKernelContext
    participant Alloc as Allocator
    
    Exec->>Sched: 初始化ready队列
    loop 直到所有节点完成
        Sched->>Exec: 取出ready节点
        Exec->>Exec: 收集输入Tensors
        Exec->>Ctx: 创建OpKernelContext
        Ctx-->>Exec: context对象
        
        Exec->>Device: Compute(kernel, ctx)
        Device->>Kernel: kernel->Compute(ctx)
        
        Kernel->>Ctx: ctx->input(0)
        Ctx-->>Kernel: 返回输入Tensor
        
        Kernel->>Ctx: ctx->input(1)
        Ctx-->>Kernel: 返回输入Tensor
        
        Kernel->>Kernel: 验证输入形状和类型
        
        Kernel->>Ctx: ctx->allocate_output(0, shape, &out)
        Ctx->>Ctx: 尝试forward输入
        alt 可以forward
            Ctx->>Ctx: 复用输入buffer
        else 必须分配新内存
            Ctx->>Alloc: AllocateRaw(num_bytes)
            Alloc-->>Ctx: 返回buffer
        end
        Ctx->>Ctx: 设置outputs_[0]
        Ctx-->>Kernel: 返回输出Tensor*
        
        Kernel->>Kernel: 执行核心计算
        Note over Kernel: 调用Eigen/BLAS/cuBLAS
        
        Kernel-->>Device: 返回（通过ctx status）
        Device-->>Exec: 返回
        
        Exec->>Exec: 检查status
        alt status不是OK
            Exec->>Exec: 传播错误并终止
        else
            Exec->>Exec: 传播输出到后继节点
            Exec->>Sched: 更新后继节点ready计数
        end
    end

class Device {
 public:
  Device(Env* env, const DeviceAttributes& attributes);
  virtual ~Device();
  
  // 核心执行方法
  virtual void Compute(OpKernel* op_kernel, OpKernelContext* context) = 0;
  virtual void ComputeAsync(AsyncOpKernel* op_kernel, 
                           OpKernelContext* context,
                           AsyncOpKernel::DoneCallback done) = 0;
  
  // 内存管理
  virtual Allocator* GetAllocator(AllocatorAttributes attr) = 0;
  virtual Allocator* GetScopedAllocator(AllocatorAttributes attr, 
                                       int64_t step_id) = 0;
  
  // Tensor操作
  virtual Status MakeTensorFromProto(const TensorProto& tensor_proto,
                                    const AllocatorAttributes alloc_attrs,
                                    Tensor* tensor) = 0;
  
  virtual void CopyTensorInSameDevice(const Tensor* input_tensor,
                                     Tensor* output_tensor,
                                     const DeviceContext* device_context,
                                     StatusCallback done) = 0;
  
  // 同步
  virtual Status Sync() = 0;
  
  // 设备信息
  const string& name() const { return attributes_.name(); }
  const DeviceType& device_type() const { return device_type_; }
  int64_t memory_limit() const { return attributes_.memory_limit(); }
  const DeviceLocality& locality() const { return attributes_.locality(); }
  
 private:
  const DeviceAttributes attributes_;
  DeviceType device_type_;
  Env* env_;  // 平台环境
};

class ThreadPoolDevice : public LocalDevice {
 public:
  ThreadPoolDevice(const SessionOptions& options, const string& name,
                   Bytes memory_limit, const DeviceLocality& locality,
                   Allocator* allocator)
      : LocalDevice(options, name, memory_limit, locality),
        allocator_(allocator),
        scoped_allocator_mgr_(new ScopedAllocatorMgr(name)) {}
  
  void Compute(OpKernel* op_kernel, OpKernelContext* context) override {
    // CPU设备直接同步执行
    
    // （此处省略日志和监控）
    
    // 调用OpKernel的Compute方法
    op_kernel->Compute(context);
    
    // （此处省略性能统计）
  }
  
  void ComputeAsync(AsyncOpKernel* op_kernel, OpKernelContext* context,
                   AsyncOpKernel::DoneCallback done) override {
    // 异步Kernel通过回调通知完成
    op_kernel->ComputeAsync(context, done);
  }
  
  Allocator* GetAllocator(AllocatorAttributes attr) override {
    // CPU使用普通分配器
    return allocator_;
  }
  
  Status Sync() override {
    // CPU设备无需显式同步
    return Status::OK();
  }
  
  Status MakeTensorFromProto(const TensorProto& proto,
                            const AllocatorAttributes alloc_attrs,
                            Tensor* tensor) override {
    // 从Proto反序列化Tensor
    return tensor->FromProto(allocator_, proto);
  }
  
 private:
  Allocator* allocator_;  // CPU内存分配器
  std::unique_ptr<ScopedAllocatorMgr> scoped_allocator_mgr_;
};

class BaseGPUDevice : public LocalDevice {
 public:
  void Compute(OpKernel* op_kernel, OpKernelContext* context) override {
    // 获取GPU执行流
    GPUDeviceContext* gpu_device_context = 
        static_cast<GPUDeviceContext*>(context->op_device_context());
    se::Stream* stream = gpu_device_context->stream();
    
    // 激活GPU上下文
    std::unique_ptr<se::ActivateContext> activation = 
        stream->parent()->Activate();
    
    // （此处省略日志和profiling）
    
    // 执行Kernel（可能是异步的）
    op_kernel->Compute(context);
    
    // （此处省略错误检查）
  }
  
  Allocator* GetAllocator(AllocatorAttributes attr) override {
    if (attr.on_host()) {
      // 分配主机固定内存（pinned memory）
      return gpu_host_allocator_;
    } else {
      // 分配GPU显存
      return gpu_allocator_;
    }
  }
  
  Status Sync() override {
    // 等待GPU执行流完成
    se::Stream* stream = device_context_->stream();
    if (!stream->BlockHostUntilDone()) {
      return errors::Internal("GPU sync failed");
    }
    return Status::OK();
  }
  
 private:
  GPUDeviceContext* device_context_;
  Allocator* gpu_allocator_;  // GPU显存分配器
  Allocator* gpu_host_allocator_;  // 固定内存分配器
};

sequenceDiagram
    autonumber
    participant Exec as Executor
    participant Node as NodeItem
    participant Dev as Device
    participant Kernel as OpKernel
    participant Stream as GPU Stream
    participant Mem as GPU Memory
    
    Exec->>Node: Process(node_item)
    Node->>Node: 准备OpKernelContext
    Node->>Dev: Device::Compute(kernel, ctx)
    
    alt CPU设备
        Dev->>Kernel: kernel->Compute(ctx)
        Kernel->>Kernel: 同步执行
        Kernel-->>Dev: 返回
    else GPU设备
        Dev->>Stream: 激活GPU context
        Stream-->>Dev: context activated
        Dev->>Kernel: kernel->Compute(ctx)
        Kernel->>Stream: 提交GPU kernel
        Stream->>Stream: 异步执行（不阻塞）
        Kernel-->>Dev: 返回（kernel已提交）
        Note over Dev: GPU kernel异步执行中
    end
    
    Dev-->>Exec: 返回
    Exec->>Exec: 传播输出
    
    opt 需要同步时
        Exec->>Dev: Sync()
        Dev->>Stream: BlockHostUntilDone()
        Stream->>Stream: 等待所有操作完成
        Stream-->>Dev: 完成
        Dev-->>Exec: OK
    end

// Tensor构造流程（核心逻辑）
Tensor::Tensor(Allocator* a, DataType type, const TensorShape& shape) 
  : shape_(shape), dtype_(type) {
  
  // 1. 计算所需内存大小
  size_t num_bytes = shape.num_elements() * DataTypeSize(type);
  
  // 2. 处理零元素情况
  if (num_bytes == 0) {
    buffer_ = nullptr;  // 零元素tensor不分配内存
    return;
  }
  
  // 3. 分配TensorBuffer
  buffer_ = a->AllocateRaw(Allocator::kAllocatorAlignment, num_bytes);
  
  // 4. 检查分配失败
  if (buffer_ == nullptr) {
    // （此处省略错误处理）
  }
  
  // 5. 初始化引用计数
  buffer_->Ref();
}

// 复制构造（浅拷贝）
Tensor::Tensor(const Tensor& other) 
  : shape_(other.shape_), dtype_(other.dtype_), buffer_(other.buffer_) {
  
  if (buffer_) buffer_->Ref();  // 增加引用计数
}

// 析构函数
Tensor::~Tensor() {
  if (buffer_) {
    buffer_->Unref();  // 减少引用计数，可能触发内存释放
  }
}