refactor(cpu): route Ling stateful ops through mllm abstractions

Author: Aharrypotter

examples/ling3/README.md

@@ -41,15 +41,15 @@ The runner emits `LING3_RUN_START`, generated token IDs, and
 runtime result; device evidence must retain the converted model SHA256 and
 the runner/library identities together.
 
-For a longer deterministic correctness demo, use the checked-in prompt and a
-64-token generation limit:
+For a longer correctness demo, pass the prompt directly and use a 64-token
+generation limit:
 
 ```bash
 ./mllm-ling3-runner \
   --model_path /path/to/Ling-3.0-tiny.mllm \
   --tokenizer_path /path/to/Ling-3.0-tiny/tokenizer.json \
   --config_path config_tiny_w4a32_kai.json \
-  --prompt_file demo_prompt_v1.txt --disable_thinking \
+  --prompt '请用中文详细介绍 Ling-3.0-tiny 的混合注意力架构，并解释 KDA、MLA 和 MoE 各自的作用。' --disable_thinking \
   --max_new_tokens 64 --print_token_ids
 ```
 

examples/ling3/demo_prompt_v1.txt

@@ -9,6 +9,7 @@
 #include "mllm/backends/cpu/ops/AvgPool1dOp.hpp"
 #include "mllm/backends/cpu/ops/CastTypeOp.hpp"
 #include "mllm/backends/cpu/ops/CausalMaskOp.hpp"
+#include "mllm/backends/cpu/ops/CausalDepthwiseConv1DOp.hpp"
 #include "mllm/backends/cpu/ops/CloneOp.hpp"
 #include "mllm/backends/cpu/ops/CmpOp.hpp"
 #include "mllm/backends/cpu/ops/ConcatOp.hpp"
@@ -36,6 +37,7 @@
 #include "mllm/backends/cpu/ops/ISTFTOp.hpp"
 #include "mllm/backends/cpu/ops/IndexOp.hpp"
 #include "mllm/backends/cpu/ops/KVCacheOp.hpp"
+#include "mllm/backends/cpu/ops/KimiDeltaAttentionOp.hpp"
 #include "mllm/backends/cpu/ops/LayerNormOp.hpp"
 #include "mllm/backends/cpu/ops/LinearOp.hpp"
 #include "mllm/backends/cpu/ops/MatMulOp.hpp"
@@ -83,7 +85,7 @@ CPUBackend::CPUBackend() : Backend(kCPU, createCPUAllocator()) {
                CPUConv2DOpFactory, CPULayerNorm2DOpFactory, CPUInterpolateOpFactory, CPUPadOpFactory, CPUMaskedScatterOpFactory,
                CPUArgsortOpFactory, CPUCloneOpFactory, CPUAvgPool1dOpFactory, CPUFlashAttention2SwaSinkOpFactory,
                CPURadixAttnRelaxOpFactory, CPURadixAttnSwaSinkOpFactory, CPUEqualOpFactory, CPUWhereOpFactory,
-               CPUGatherOpFactory>();
+               CPUGatherOpFactory, CPUKimiDeltaAttentionOpFactory, CPUCausalDepthwiseConv1DOpFactory>();
 }
 
 CPUBackend::~CPUBackend() {

mllm/backends/cpu/CPUBackend.cpp

@@ -0,0 +1,31 @@
+// Copyright (c) MLLM Team.
+// Licensed under the MIT License.
+
+#include "mllm/backends/cpu/ops/CausalDepthwiseConv1DOp.hpp"
+
+#include <cstring>
+#include <stdexcept>
+
+#include "mllm/backends/cpu/kernels/common/gdn/gated_delta_net.hpp"
+
+namespace mllm::cpu {
+
+CPUCausalDepthwiseConv1DOp::CPUCausalDepthwiseConv1DOp(const aops::CausalDepthwiseConv1DOpOptions& options)
+    : aops::CausalDepthwiseConv1DOp(options) {}
+
+void CPUCausalDepthwiseConv1DOp::forward(const std::vector<Tensor>& inputs, std::vector<Tensor>& outputs) {
+  for (const auto& input : inputs) {
+    if (!input.isContiguous()) { throw std::invalid_argument("CausalDepthwiseConv1D CPU inputs must be contiguous"); }
+  }
+
+  const auto& input = inputs[0];
+  const auto& weight = inputs[1];
+  const auto& state = inputs[2];
+  auto& output = outputs[0];
+  auto& updated_state = outputs[1];
+  if (!options_.state_inplace) { std::memcpy(updated_state.ptr<float>(), state.ptr<float>(), state.bytes()); }
+  gdn::depthwiseCausalConvF32(input.ptr<float>(), weight.ptr<float>(), updated_state.ptr<float>(), output.ptr<float>(),
+                              input.shape()[0], input.shape()[1], input.shape()[2], weight.shape()[2]);
+}
+
+}  // namespace mllm::cpu

mllm/backends/cpu/ops/CausalDepthwiseConv1DOp.cpp

@@ -0,0 +1,25 @@
+// Copyright (c) MLLM Team.
+// Licensed under the MIT License.
+
+#pragma once
+
+#include "mllm/core/aops/CausalDepthwiseConv1DOp.hpp"
+
+namespace mllm::cpu {
+
+class CPUCausalDepthwiseConv1DOp final : public aops::CausalDepthwiseConv1DOp {
+ public:
+  explicit CPUCausalDepthwiseConv1DOp(const aops::CausalDepthwiseConv1DOpOptions& options);
+
+  void forward(const std::vector<Tensor>& inputs, std::vector<Tensor>& outputs) override;
+};
+
+class CPUCausalDepthwiseConv1DOpFactory
+    : public TypedOpFactory<OpTypes::kCausalDepthwiseConv1D, aops::CausalDepthwiseConv1DOpOptions> {
+ public:
+  std::shared_ptr<BaseOp> createOpImpl(const aops::CausalDepthwiseConv1DOpOptions& options) override {
+    return std::make_shared<CPUCausalDepthwiseConv1DOp>(options);
+  }
+};
+
+}  // namespace mllm::cpu

mllm/backends/cpu/ops/CausalDepthwiseConv1DOp.hpp

@@ -0,0 +1,31 @@
+// Copyright (c) MLLM Team.
+// Licensed under the MIT License.
+
+#include "mllm/backends/cpu/ops/KimiDeltaAttentionOp.hpp"
+
+#include <cstring>
+#include <stdexcept>
+
+#include "mllm/backends/cpu/kernels/common/kda/kimi_delta_attention.hpp"
+
+namespace mllm::cpu {
+
+CPUKimiDeltaAttentionOp::CPUKimiDeltaAttentionOp(const aops::KimiDeltaAttentionOpOptions& options)
+    : aops::KimiDeltaAttentionOp(options) {}
+
+void CPUKimiDeltaAttentionOp::forward(const std::vector<Tensor>& inputs, std::vector<Tensor>& outputs) {
+  for (const auto& input : inputs) {
+    if (!input.isContiguous()) { throw std::invalid_argument("KimiDeltaAttention CPU inputs must be contiguous"); }
+  }
+
+  const auto& q = inputs[0];
+  auto& output = outputs[0];
+  auto& updated_state = outputs[1];
+  if (!options_.state_inplace) { std::memcpy(updated_state.ptr<float>(), inputs[7].ptr<float>(), inputs[7].bytes()); }
+  kda::kimiDeltaAttentionF32(inputs[0].ptr<float>(), inputs[1].ptr<float>(), inputs[2].ptr<float>(), inputs[3].ptr<float>(),
+                             inputs[4].ptr<float>(), inputs[5].ptr<float>(), inputs[6].ptr<float>(), updated_state.ptr<float>(),
+                             output.ptr<float>(), q.shape()[0], q.shape()[1], q.shape()[2], q.shape()[3], options_.safe_gate,
+                             options_.lower_bound, options_.getThreads());
+}
+
+}  // namespace mllm::cpu

mllm/backends/cpu/ops/KimiDeltaAttentionOp.cpp

@@ -0,0 +1,24 @@
+// Copyright (c) MLLM Team.
+// Licensed under the MIT License.
+
+#pragma once
+
+#include "mllm/core/aops/KimiDeltaAttentionOp.hpp"
+
+namespace mllm::cpu {
+
+class CPUKimiDeltaAttentionOp final : public aops::KimiDeltaAttentionOp {
+ public:
+  explicit CPUKimiDeltaAttentionOp(const aops::KimiDeltaAttentionOpOptions& options);
+
+  void forward(const std::vector<Tensor>& inputs, std::vector<Tensor>& outputs) override;
+};
+
+class CPUKimiDeltaAttentionOpFactory : public TypedOpFactory<OpTypes::kKimiDeltaAttention, aops::KimiDeltaAttentionOpOptions> {
+ public:
+  std::shared_ptr<BaseOp> createOpImpl(const aops::KimiDeltaAttentionOpOptions& options) override {
+    return std::make_shared<CPUKimiDeltaAttentionOp>(options);
+  }
+};
+
+}  // namespace mllm::cpu

mllm/backends/cpu/ops/KimiDeltaAttentionOp.hpp

@@ -1,4 +1,4 @@
-// Auto generated: 2026-01-09 07:46:43
+// Auto generated: 2026-08-13 00:11:43
 // do not modify this file
 #pragma once
 
@@ -51,6 +51,8 @@ enum NodeKind : uint32_t {
   RK_Op_LinalgIROp_MultimodalRoPEOp,
   RK_Op_LinalgIROp_VisionRoPEOp,
   RK_Op_LinalgIROp_QuickGELUOp,
+  RK_Op_LinalgIROp_KimiDeltaAttentionOp,
+  RK_Op_LinalgIROp_CausalDepthwiseConv1DOp,
   RK_Op_LinalgIROp_CopyOp,
   RK_Op_LinalgIROp_CloneOp,
   RK_Op_LinalgIROp_NegOp,

mllm/compile/ir/GeneratedRTTIKind.hpp

@@ -1,4 +1,4 @@
-// Auto generated: 2026-01-09 07:46:43
+// Auto generated: 2026-08-13 00:11:43
 // do not modify this file
 #pragma once
 namespace mllm::ir {
@@ -123,6 +123,13 @@ struct NodeRTTIClassOfImpl {
 #define RTTI_RK_OP_LINALGIROP_QUICKGELUOP_IMPL(v) \
   return (v)->getKind() >= RK_Op_LinalgIROp_QuickGELUOp && (v)->getKind() <= RK_Op_LinalgIROp_QuickGELUOp
 
+#define RTTI_RK_OP_LINALGIROP_KIMIDELTAATTENTIONOP_IMPL(v) \
+  return (v)->getKind() >= RK_Op_LinalgIROp_KimiDeltaAttentionOp && (v)->getKind() <= RK_Op_LinalgIROp_KimiDeltaAttentionOp
+
+#define RTTI_RK_OP_LINALGIROP_CAUSALDEPTHWISECONV1DOP_IMPL(v)       \
+  return (v)->getKind() >= RK_Op_LinalgIROp_CausalDepthwiseConv1DOp \
+         && (v)->getKind() <= RK_Op_LinalgIROp_CausalDepthwiseConv1DOp
+
 #define RTTI_RK_OP_LINALGIROP_COPYOP_IMPL(v) \
   return (v)->getKind() >= RK_Op_LinalgIROp_CopyOp && (v)->getKind() <= RK_Op_LinalgIROp_CopyOp
 

mllm/compile/ir/NodeRTTIClassOfImpl.hpp

@@ -80,6 +80,8 @@ LINALG_AOPS_DECL(OpTypes::kMultimodalRoPE, MultimodalRoPEOp);
 LINALG_AOPS_DECL(OpTypes::kVisionRoPE, VisionRoPEOp);
 
 LINALG_AOPS_DECL(OpTypes::kQuickGELU, QuickGELUOp);
+LINALG_AOPS_DECL(OpTypes::kKimiDeltaAttention, KimiDeltaAttentionOp);
+LINALG_AOPS_DECL(OpTypes::kCausalDepthwiseConv1D, CausalDepthwiseConv1DOp);
 
 LINALG_AOPS_DECL(OpTypes::kCopy, CopyOp);
 LINALG_AOPS_DECL(OpTypes::kClone, CloneOp);